grpc spring

This document provides an overview of two distinct projects: gRPC/Spring, a Spring Boot starter for gRPC, and Mitsuba 3, a research-oriented rendering system. The gRPC/Spring section details its features, usage instructions, and compatibility information. The Mitsuba 3 section covers its installation, usage, features, and contributors. Both sections include code examples and links to further documentation.

Survey - gRPC/Spring

Dear gRPC/Spring users, in order to enhance the user experience of

grpc-ecosystem/grpc-spring, we have developed this survey as a means of

establishing a direct line of communication. Your feedback is highly appreciated.

gRPC Spring Boot Starter

README: English | 中文

Documentation: English | 中文

Features

Automatically configures and runs the gRPC server with your @GrpcService implementations

Automatically creates and manages your grpc channels and stubs with @GrpcClient

Supports other grpc-java flavors (e.g.

Reactive gRPC (RxJava),

grpc-kotlin, ...)

Supports Spring-Security

Supports Spring Cloud

Supports Spring Sleuth as distributed tracing solution

(If brave-instrumentation-grpc is present)

Supports global and custom gRPC server/client interceptors

Automatic metric support (micrometer/actuator based)

Also works with (non-shaded) grpc-netty

Versions

The latest version is 3.1.0.RELEASE it was compiled with spring-boot 3.2.4 and spring-cloud 2023.0.0

but it is also compatible with a large variety of other versions.

An overview of all versions and their respective library versions can be found in our documentation.

Note: This project can also be used without Spring-Boot, however that requires some manual bean configuration.

Usage

gRPC Server + Client

To add a dependency using Maven, use the following:

To add a dependency using Gradle:

gRPC Server

To add a dependency using Maven, use the following:

To add a dependency using Gradle:

Annotate your server interface implementation(s) with @GrpcService

By default, the grpc server will listen to port 9090. These and other

settings

can be changed via Spring's property mechanism. The server uses the grpc.server. prefix.

Refer to our documentation for more details.

gRPC Client

To add a dependency using Maven, use the following:

To add a dependency using Gradle:

Annotate a field of your grpc client stub with @GrpcClient(serverName)

Do not use in conjunction with @Autowired or @Inject

Note: You can use the same grpc server name for multiple channels and also different stubs (even with different

interceptors).

Then you can send queries to your server just like this:

It is possible to configure the target address for each client individually.

However in some cases, you can just rely on the default configuration.

You can customize the default url mapping via NameResolver.Factory beans. If you don't configure that bean,

then the default uri will be guessed using the default scheme and the name (e.g.: dns:/

):

These and other

settings

can be changed via Spring's property mechanism. The clients use the grpc.client.(serverName). prefix.

Refer to our documentation for more details.

Running with (non-shaded) grpc-netty

This library supports both grpc-netty and grpc-netty-shaded.

The later one might prevent conflicts with incompatible grpc-versions or conflicts between libraries that require different versions of netty.

Note: If the shaded netty is present on the classpath, then this library will always favor it over the non-shaded grpc-netty one.

You can use it with Maven like this:

and like this when using Gradle:

Example-Projects

Read more about our example projects here.

Troubleshooting

Refer to our documentation for help.

Contributing

Contributions are always welcomed! Please see CONTRIBUTING.md for detailed guidelines.

example:

Mitsuba Renderer 3

Documentation

Tutorial videos

Linux

MacOS

Windows

PyPI

Warning

There currently is a large amount of undocumented and unstable work going on in

the master branch. We'd highly recommend you use our

latest release

until further notice.

If you already want to try out the upcoming changes, please have a look at

this porting guide.

It should cover most of the new features and breaking changes that are coming.

Introduction

Mitsuba 3 is a research-oriented rendering system for forward and inverse light

transport simulation developed at EPFL in Switzerland.

It consists of a core library and a set of plugins that implement functionality

ranging from materials and light sources to complete rendering algorithms.

Mitsuba 3 is retargetable: this means that the underlying implementations and

data structures can transform to accomplish various different tasks. For

example, the same code can simulate both scalar (classic one-ray-at-a-time) RGB transport

or differential spectral transport on the GPU. This all builds on

Dr.Jit, a specialized just-in-time(JIT) compiler developed specifically for this project.

Main Features

Cross-platform: Mitsuba 3 has been tested on Linux (x86_64), macOS

(aarch64, x8664), and Windows (x8664).

High performance: The underlying Dr.Jit compiler fuses rendering code

into kernels that achieve state-of-the-art performance using

an LLVM backend targeting the CPU and a CUDA/OptiX backend

targeting NVIDIA GPUs with ray tracing hardware acceleration.

Python first: Mitsuba 3 is deeply integrated with Python. Materials,

textures, and even full rendering algorithms can be developed in Python,

which the system JIT-compiles (and optionally differentiates) on the fly.

This enables the experimentation needed for research in computer graphics and

other disciplines.

Differentiation: Mitsuba 3 is a differentiable renderer, meaning that it

can compute derivatives of the entire simulation with respect to input

parameters such as camera pose, geometry, BSDFs, textures, and volumes. It

implements recent differentiable rendering algorithms developed at EPFL.

Spectral & Polarization: Mitsuba 3 can be used as a monochromatic

renderer, RGB-based renderer, or spectral renderer. Each variant can

optionally account for the effects of polarization if desired.

Tutorial videos, documentation

We've recorded several YouTube videos that provide a gentle introduction

Mitsuba 3 and Dr.Jit. Beyond this you can find complete Juypter notebooks

covering a variety of applications, how-to guides, and reference documentation

on readthedocs.

Installation

We provide pre-compiled binary wheels via PyPI. Installing Mitsuba this way is as simple as running

pip install mitsuba

on the command line. The Python package includes thirteen variants by default:

scalar_rgb

scalar_spectral

scalarspectralpolarized

llvmadrgb

llvmadmono

llvmadmono_polarized

llvmadspectral

llvmadspectral_polarized

cudaadrgb

cudaadmono

cudaadmono_polarized

cudaadspectral

cudaadspectral_polarized

The first two perform classic one-ray-at-a-time simulation using either a RGB

or spectral color representation, while the latter two can be used for inverse

rendering on the CPU or GPU. To access additional variants, you will need to

compile a custom version of Dr.Jit using CMake. Please see the

documentation

for details on this.

Requirements

Python >= 3.8

(optional) For computation on the GPU: Nvidia driver >= 495.89

(optional) For vectorized / parallel computation on the CPU: LLVM >= 11.1

Usage

Here is a simple "Hello World" example that shows how simple it is to render a

scene using Mitsuba 3 from Python:

# Import the library using the alias "mi"import mitsuba as mi# Set the variant of the renderermi.setvariant('scalarrgb')# Load a scenescene = mi.loaddict(mi.cornellbox())# Render the sceneimg = mi.render(scene)# Write the rendered image to an EXR filemi.Bitmap(img).write('cbox.exr')

Tutorials and example notebooks covering a variety of applications can be found

in the documentation.

About

This project was created by Wenzel Jakob.

Significant features and/or improvements to the code were contributed by

Sébastien Speierer,

Nicolas Roussel,

Merlin Nimier-David,

Delio Vicini,

Tizian Zeltner,

Baptiste Nicolet,

Miguel Crespo,

Vincent Leroy, and

Ziyi Zhang.

When using Mitsuba 3 in academic projects, please cite:

@software{Mitsuba3,title = {Mitsuba 3 renderer},author = {Wenzel Jakob and Sébastien Speierer and Nicolas Roussel and Merlin Nimier-David and Delio Vicini and Tizian Zeltner and Baptiste Nicolet and Miguel Crespo and Vincent Leroy and Ziyi Zhang},note = {https://mitsuba-renderer.org},version = {3.1.1},year = 2022}