Search Results for: open source

code.visualstudio.com/

https://www.freecodecamp.org/news/how-to-set-up-vs-code-for-web-development/

wandb.ai/stacey/greenscreen/reports/Two-Shots-to-Green-Screen-Collage-With-Deep-Learning--VmlldzoxMDc4MjY

grail.cs.washington.edu/projects/background-matting/

www.gafferhq.org/

darbyjohnston.github.io/DJV/

sourceforge.net/projects/djv/

[vimeo 427238947 250 250]

https://openai.com/blog/openai-api/

www.colour-science.org/

awesome-colour.org/

https://fspy.io/

https://dust3d.org/

https://www.tensorflow.org/

http://mitchtech.net/raspberry-pi-opencv/

https://opencv.org/

www.bluegriffon.org

BlueGriffon is an open source WYSIWYG editor powered by Gecko, the rendering engine developed for Mozilla Firefox. One of a few derivatives of NVU, a now-discontinued HTML editor, BlueGriffon is the only actively developed NVU derivative that supports HTML5 as well as modern components of CSS.

If your goal is to write as little actual HTML as possible, then BlueGriffon is the tool you want. It’s a true drag-and-drop WYSIWYG website designer, and even includes a dual view option so you can see the code behind your design, in case you want to edit it or just learn from it.

It also supports the EPUB ebook format, so you don’t have to just publish to the web: you can provide your readers with a download of your content that they can take with them. Licensed under the MPL, GPL, and LGPL, a version of BlueGriffon is available for Linux, Windows, and Mac.

Source: opensource.com/alternatives/dreamweaver

https://fspy.io/

blogs.nvidia.com/blog/2019/03/18/omniverse-collaboration-platform/

developer.nvidia.com/nvidia-omniverse

An open, Interactive 3D Design Collaboration Platform for Multi-Tool Workflows to simplify studio workflows for real-time graphics.

It supports Pixar’s Universal Scene Description technology for exchanging information about modeling, shading, animation, lighting, visual effects and rendering across multiple applications.

It also supports NVIDIA’s Material Definition Language, which allows artists to exchange information about surface materials across multiple tools.

With Omniverse, artists can see live updates made by other artists working in different applications. They can also see changes reflected in multiple tools at the same time.

For example an artist using Maya with a portal to Omniverse can collaborate with another artist using UE4 and both will see live updates of each others’ changes in their application.

openai.com/

edition.cnn.com/2019/02/18/tech/dangerous-ai-text-generator/index.html

OpenAI researchers fed the following Lord-of-the-Rings-style prompt to the system: Legolas and Gimli advanced on the orcs, raising their weapons with a harrowing war cry.

The computer composed this appropriately violent addition:

The orcs’ response was a deafening onslaught of claws, claws, and claws; even Elrond was forced to retreat. “You are in good hands, dwarf,” said Gimli, who had been among the first to charge at the orcs; it took only two words before their opponents were reduced to a blood-soaked quagmire, and the dwarf took his first kill of the night.”

The company’s decision to keep it from public use is the latest indication of a growing unease in and about the tech community about building cutting-edge technology — in particular AI —without setting limits on how it can be deployed.

Amazon and Microsoft in particular have voiced their support for legislation to regulate how facial recognition technology can and can’t be used. And Amazon investors and employees (as well as a dozens of civil rights groups) have urged the company to stop selling its face-recognition technology, Rekognition, to government agencies due to concerns it could be used to violate people’s rights.

alicevision.github.io/#meshroom

HandBrake is a tool for converting video from nearly any format to a selection of modern, widely supported codecs

https://handbrake.fr/

https://inkscape.org/en/

https://vectr.com/

http://betanews.com/2017/01/13/google-draco-3d-graphics-open-source-github/

http://hackaday.com/2016/12/24/open-source-parametric-cad-in-your-browser/

https://github.com/xibyte/jsketcher

https://www.tensorflow.org/

how to classify images with tensorflow

http://techcrunch.com/2014/05/15/antvr-kit/

https://www.apertus.org/

The goal of the community driven apertus° project is to create a variety of powerful, free (in terms of liberty) and open cinema tools that we as filmmakers love to use.

http://www.darktable.org/features/

https://github.com/stitionai/devika

https://github.com/nalaso/devika/tree/main

https://docs.gsplat.studio/

https://stable-diffusion-art.com/sdxl-model/

https://the-decoder.com/zeroscope-is-a-free-text-to-video-model-that-runs-on-modern-graphics-cards/

https://huggingface.co/cerspense/zeroscope_v2_XL

The Cattery is a library of free third-party machine learning models converted to .cat files to run natively in Nuke, designed to bridge the gap between academia and production, providing all communities access to different ML models that all run in Nuke. Users will have access to state-of-the-art models addressing segmentation, depth estimation, optical flow, upscaling, denoising, and style transfer, with plans to expand the models hosted in the future.

https://www.foundry.com/insights/machine-learning/the-artists-guide-to-cattery

https://community.foundry.com/cattery

wonderunit.com/storyboarder/

Text2Light

• https://www.cgtrader.com/free-3d-models/exterior/other/10-free-hdr-panoramas-created-with-text2light-zero-shot
• https://frozenburning.github.io/projects/text2light/
• https://github.com/FrozenBurning/Text2Light

Royalty free links

• https://locationtextures.com/panoramas/
• http://www.noahwitchell.com/freebies
• https://polyhaven.com/hdris
• https://hdrmaps.com/
• https://www.ihdri.com/
• https://hdrihaven.com/
• https://www.domeble.com/
• http://www.hdrlabs.com/sibl/archive.html
• https://www.hdri-hub.com/hdrishop/hdri
• http://noemotionhdrs.net/hdrevening.html
• https://www.openfootage.net/hdri-panorama/
• https://www.zwischendrin.com/en/browse/hdri

Nvidia GauGAN360

• https://www.youtube.com/watch?v=2YwTkrmogDg
• http://imaginaire.cc/gaugan360/

https://github.com/matiascodesal/awesome-usd

https://www.freecodecamp.org/news/advanced-computer-vision-with-python/

https://www.freecodecamp.org/news/how-to-use-opencv-and-python-for-computer-vision-and-ai/

Working for a VFX (Visual Effects) studio provides numerous opportunities to leverage the power of Python and OpenCV for various tasks. OpenCV is a versatile computer vision library that can be applied to many aspects of the VFX pipeline. Here’s a detailed list of opportunities to take advantage of Python and OpenCV in a VFX studio:

1. Image and Video Processing:
   • Preprocessing: Python and OpenCV can be used for tasks like resizing, color correction, noise reduction, and frame interpolation to prepare images and videos for further processing.
   • Format Conversion: Convert between different image and video formats using OpenCV’s capabilities.
2. Tracking and Matchmoving:
   • Feature Detection and Tracking: Utilize OpenCV to detect and track features in image sequences, which is essential for matchmoving tasks to integrate computer-generated elements into live-action footage.
3. Rotoscoping and Masking:
   • Segmentation and Masking: Use OpenCV for creating and manipulating masks and alpha channels for various VFX tasks, like isolating objects or characters from their backgrounds.
4. Camera Calibration:
   • Intrinsic and Extrinsic Calibration: Python and OpenCV can help calibrate cameras for accurate 3D scene reconstruction and camera tracking.
5. 3D Scene Reconstruction:
   • Stereoscopy: Use OpenCV to process stereoscopic image pairs for creating 3D depth maps and generating realistic 3D scenes.
   • Structure from Motion (SfM): Implement SfM techniques to create 3D models from 2D image sequences.
6. Green Screen and Blue Screen Keying:
   • Chroma Keying: Implement advanced keying algorithms using OpenCV to seamlessly integrate actors and objects into virtual environments.
7. Particle and Fluid Simulations:
   • Particle Tracking: Utilize OpenCV to track and manipulate particles in fluid simulations for more realistic visual effects.
8. Motion Analysis:
   • Optical Flow: Implement optical flow algorithms to analyze motion patterns in footage, useful for creating dynamic VFX elements that follow the motion of objects.
9. Virtual Set Extension:
   • Camera Projection: Use camera calibration techniques to project virtual environments onto physical sets, extending the visual scope of a scene.
10. Color Grading:
    • Color Correction: Implement custom color grading algorithms to match the color tones and moods of different shots.
11. Automated QC (Quality Control):
    • Artifact Detection: Develop Python scripts to automatically detect and flag visual artifacts like noise, flicker, or compression artifacts in rendered frames.
12. Data Analysis and Visualization:
    • Performance Metrics: Use Python to analyze rendering times and optimize the rendering process.
    • Data Visualization: Generate graphs and charts to visualize render farm usage, project progress, and resource allocation.
13. Automating Repetitive Tasks:
    • Batch Processing: Automate repetitive tasks like resizing images, applying filters, or converting file formats across multiple shots.
14. Machine Learning Integration:
    • Object Detection: Integrate machine learning models (using frameworks like TensorFlow or PyTorch) to detect and track specific objects or elements within scenes.
15. Pipeline Integration:
    • Custom Tools: Develop Python scripts and tools to integrate OpenCV-based processes seamlessly into the studio’s pipeline.
16. Real-time Visualization:
    • Live Previsualization: Implement real-time OpenCV-based visualizations to aid decision-making during the preproduction stage.
17. VR and AR Integration:
    • Augmented Reality: Use Python and OpenCV to integrate virtual elements into real-world footage, creating compelling AR experiences.
18. Camera Effects:
    • Lens Distortion: Correct lens distortions and apply various camera effects using OpenCV, contributing to the desired visual style.

Interpolating frames from an EXR sequence using OpenCV can be useful when you have only every second frame of a final render and you want to create smoother motion by generating intermediate frames. However, keep in mind that interpolating frames might not always yield perfect results, especially if there are complex changes between frames. Here’s a basic example of how you might use OpenCV to achieve this:

import cv2
import numpy as np
import os

# Replace with the path to your EXR frames
exr_folder = "path_to_exr_frames"

# Replace with the appropriate frame extension and naming convention
frame_template = "frame_{:04d}.exr"

# Define the range of frame numbers you have
start_frame = 1
end_frame = 100
step = 2

# Define the output folder for interpolated frames
output_folder = "output_interpolated_frames"
os.makedirs(output_folder, exist_ok=True)

# Loop through the frame range and interpolate
for frame_num in range(start_frame, end_frame + 1, step):
    frame_path = os.path.join(exr_folder, frame_template.format(frame_num))
    next_frame_path = os.path.join(exr_folder, frame_template.format(frame_num + step))

    if os.path.exists(frame_path) and os.path.exists(next_frame_path):
        frame = cv2.imread(frame_path, cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)
        next_frame = cv2.imread(next_frame_path, cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)

        # Interpolate frames using simple averaging
        interpolated_frame = (frame + next_frame) / 2

        # Save interpolated frame
        output_path = os.path.join(output_folder, frame_template.format(frame_num))
        cv2.imwrite(output_path, interpolated_frame)

        print(f"Interpolated frame {frame_num}") # alternatively: print("Interpolated frame {}".format(frame_num))

Please note the following points:

• The above example uses simple averaging to interpolate frames. More advanced interpolation methods might provide better results, such as motion-based algorithms like optical flow-based interpolation.
• EXR files can store high dynamic range (HDR) data, so make sure to use cv2.IMREAD_ANYDEPTH flag when reading these files.
• OpenCV might not support EXR format directly. You might need to use a library like exr to read and manipulate EXR files, and then convert them to OpenCV-compatible formats.
• Consider the characteristics of your specific render when using interpolation. If there are large changes between frames, the interpolation might lead to artifacts.
• Experiment with different interpolation methods and parameters to achieve the desired result.
• For a more advanced and accurate interpolation, you might need to implement or use existing algorithms that take into account motion estimation and compensation.

http://answers.unity3d.com/questions/12321/how-can-i-start-learning-unity-fast-list-of-tutori.html

If you have no previous experience with Unity, start with these six video tutorials which give a quick overview of the Unity interface and some important features http://unity3d.com/support/documentation/video/

(more…)

http://opencolorio.org/

https://www.provideocoalition.com/color-management-part-11-introducing-opencolorio/

OpenColorIO (OCIO) is a new open source project from Sony Imageworks.

Based on development started in 2003, OCIO enables color transforms and image display to be handled in a consistent manner across multiple graphics applications. Unlike other color management solutions, OCIO is geared towards motion-picture post production, with an emphasis on visual effects and animation color pipelines.

https://education.civitai.com/generative-ai-glossary/

https://numpy.org/doc/stable/user/absolute_beginners.html

NumPy (Numerical Python) is an open source Python library that’s used in almost every field of science and engineering. It’s the universal standard for working with numerical data in Python, and it’s at the core of the scientific Python and PyData ecosystems. NumPy users include everyone from beginning coders to experienced researchers doing state-of-the-art scientific and industrial research and development. The NumPy API is used extensively in Pandas, SciPy, Matplotlib, scikit-learn, scikit-image and most other data science and scientific Python packages.

The NumPy library contains multidimensional array and matrix data structures (you’ll find more information about this in later sections). It provides ndarray, a homogeneous n-dimensional array object, with methods to efficiently operate on it. NumPy can be used to perform a wide variety of mathematical operations on arrays. It adds powerful data structures to Python that guarantee efficient calculations with arrays and matrices and it supplies an enormous library of high-level mathematical functions that operate on these arrays and matrices.

https://www.slashcam.com/news/single/Netflix-removes-movie-noise--saves-30--bandwidth-a-17337.html

”’Filmmaker Parker Gibbons has drawn attention to a very interesting fact: Netflix removes film noise before streaming its movies and artificially adds it back when decoding. This is because digitally shot films are actually free of any film grain, the very specific (not to be confused with noise caused by too little light) noise that occurs in analog filming. But this type of noise has become so associated with “real” motion pictures through the long history of film (as a component of the film look) that it is unconsciously perceived by many viewers as an important feature of a motion picture.

…

This leads to a difficult-to-resolve contradiction between, on the one hand, film material that is as compressible and noise-free as possible, and, on the other hand, the noise caused by film grain that is desirable for the film look. Netflix has found a very special solution to resolve this contradiction. It uses a very special function of the open source AV1 video codec, which Netflix has been using for a long time, namely the artificial synthesis of film grain. Thus, film noise is first analyzed using statistical methods before compression and then removed for efficient compression. According to Netflix, this saves around 30% of the data during transmission.”’

http://etherpad.org/

a highly customizable Open Source online editor providing collaborative editing in really real-time

https://processing.org/

Processing is a flexible software sketchbook and a language for learning how to code within the context of the visual arts. Since 2001, Processing has promoted software literacy within the visual arts and visual literacy within technology. There are tens of thousands of students, artists, designers, researchers, and hobbyists who use Processing for learning and prototyping.

» Free to download and open source
» Interactive programs with 2D, 3D or PDF output
» OpenGL integration for accelerated 2D and 3D
» For GNU/Linux, Mac OS X, Windows, Android, and ARM
» Over 100 libraries extend the core software