griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
dcac86f4f11fb4e464a8f2dc3f2ef69eff4f4f21
test2/source/blender/compositor/operations/COM_TransformOperation.cc
Manuel Castilla f84fb12f5d Compositor: Add support for canvas compositing 
This commit adds functionality for operations that require pixel
translation or resizing on "Full Frame" mode, allowing to adjust
their canvas. It fixes most cropping issues in translate, scale,
rotate and transform nodes by adjusting their canvas to the result,
instead of the input canvas.

Operations output buffer is still always on (0,0) position for
easier image algorithm implementation, even when the
canvas is not.

Current limitations (will be addressed on bcon2):
- Displayed translation in Viewer node is limited to 6000px.
- When scaling up the canvas size is limited to the
 scene resolution size x 1.5 . From that point it crops.

If none of these limitations are hit, the Viewer node displays
the full input with any translation.

Differential Revision: https://developer.blender.org/D12466
2021-09-28 22:00:17 +02:00

236 lines
9.3 KiB
C++
Raw Blame History

/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Copyright 2021, Blender Foundation.
*/
#include "COM_TransformOperation.h"
#include "COM_ConstantOperation.h"
#include "COM_RotateOperation.h"
#include "COM_ScaleOperation.h"
#include "BLI_math.h"
namespace blender::compositor {
TransformOperation::TransformOperation()
{
addInputSocket(DataType::Color, ResizeMode::None);
addInputSocket(DataType::Value, ResizeMode::None);
addInputSocket(DataType::Value, ResizeMode::None);
addInputSocket(DataType::Value, ResizeMode::None);
addInputSocket(DataType::Value, ResizeMode::None);
addOutputSocket(DataType::Color);
translate_factor_x_ = 1.0f;
translate_factor_y_ = 1.0f;
convert_degree_to_rad_ = false;
sampler_ = PixelSampler::Bilinear;
invert_ = false;
max_scale_canvas_size_ = {ScaleOperation::DEFAULT_MAX_SCALE_CANVAS_SIZE,
ScaleOperation::DEFAULT_MAX_SCALE_CANVAS_SIZE};
}
void TransformOperation::set_scale_canvas_max_size(Size2f size)
{
max_scale_canvas_size_ = size;
}
void TransformOperation::init_data()
{
translate_x_ = get_input_operation(X_INPUT_INDEX)->get_constant_value_default(0.0f) *
translate_factor_x_;
translate_y_ = get_input_operation(Y_INPUT_INDEX)->get_constant_value_default(0.0f) *
translate_factor_y_;
const float degree = get_input_operation(DEGREE_INPUT_INDEX)->get_constant_value_default(0.0f);
const double rad = convert_degree_to_rad_ ? DEG2RAD((double)degree) : degree;
rotate_cosine_ = cos(rad);
rotate_sine_ = sin(rad);
scale_ = get_input_operation(SCALE_INPUT_INDEX)->get_constant_value_default(1.0f);
}
void TransformOperation::get_area_of_interest(const int input_idx,
const rcti &output_area,
rcti &r_input_area)
{
switch (input_idx) {
case IMAGE_INPUT_INDEX: {
NodeOperation *image_op = get_input_operation(IMAGE_INPUT_INDEX);
const rcti &image_canvas = image_op->get_canvas();
if (invert_) {
/* Scale -> Rotate -> Translate. */
r_input_area = output_area;
BLI_rcti_translate(&r_input_area, -translate_x_, -translate_y_);
RotateOperation::get_rotation_area_of_interest(scale_canvas_,
rotate_canvas_,
rotate_sine_,
rotate_cosine_,
r_input_area,
r_input_area);
ScaleOperation::get_scale_area_of_interest(
image_canvas, scale_canvas_, scale_, scale_, r_input_area, r_input_area);
}
else {
/* Translate -> Rotate -> Scale. */
ScaleOperation::get_scale_area_of_interest(
rotate_canvas_, scale_canvas_, scale_, scale_, output_area, r_input_area);
RotateOperation::get_rotation_area_of_interest(translate_canvas_,
rotate_canvas_,
rotate_sine_,
rotate_cosine_,
r_input_area,
r_input_area);
BLI_rcti_translate(&r_input_area, -translate_x_, -translate_y_);
}
expand_area_for_sampler(r_input_area, sampler_);
break;
}
case X_INPUT_INDEX:
case Y_INPUT_INDEX:
case DEGREE_INPUT_INDEX:
case SCALE_INPUT_INDEX: {
r_input_area = COM_CONSTANT_INPUT_AREA_OF_INTEREST;
break;
}
}
}
void TransformOperation::update_memory_buffer_partial(MemoryBuffer *output,
const rcti &area,
Span<MemoryBuffer *> inputs)
{
const MemoryBuffer *input_img = inputs[IMAGE_INPUT_INDEX];
BuffersIterator<float> it = output->iterate_with({}, area);
if (invert_) {
transform_inverted(it, input_img);
}
else {
transform(it, input_img);
}
}
void TransformOperation::determine_canvas(const rcti &preferred_area, rcti &r_area)
{
const bool image_determined =
getInputSocket(IMAGE_INPUT_INDEX)->determine_canvas(preferred_area, r_area);
if (image_determined) {
rcti image_canvas = r_area;
rcti unused;
getInputSocket(X_INPUT_INDEX)->determine_canvas(image_canvas, unused);
getInputSocket(Y_INPUT_INDEX)->determine_canvas(image_canvas, unused);
getInputSocket(DEGREE_INPUT_INDEX)->determine_canvas(image_canvas, unused);
getInputSocket(SCALE_INPUT_INDEX)->determine_canvas(image_canvas, unused);
init_data();
if (invert_) {
/* Scale -> Rotate -> Translate. */
scale_canvas_ = image_canvas;
ScaleOperation::scale_area(scale_canvas_, scale_, scale_);
const Size2f max_scale_size = {
MAX2(BLI_rcti_size_x(&image_canvas), max_scale_canvas_size_.x),
MAX2(BLI_rcti_size_y(&image_canvas), max_scale_canvas_size_.y)};
ScaleOperation::clamp_area_size_max(scale_canvas_, max_scale_size);
RotateOperation::get_rotation_canvas(
scale_canvas_, rotate_sine_, rotate_cosine_, rotate_canvas_);
translate_canvas_ = rotate_canvas_;
BLI_rcti_translate(&translate_canvas_, translate_x_, translate_y_);
r_area = translate_canvas_;
}
else {
/* Translate -> Rotate -> Scale. */
translate_canvas_ = image_canvas;
BLI_rcti_translate(&translate_canvas_, translate_x_, translate_y_);
RotateOperation::get_rotation_canvas(
translate_canvas_, rotate_sine_, rotate_cosine_, rotate_canvas_);
scale_canvas_ = rotate_canvas_;
ScaleOperation::scale_area(scale_canvas_, scale_, scale_);
const Size2f max_scale_size = {
MAX2(BLI_rcti_size_x(&rotate_canvas_), max_scale_canvas_size_.x),
MAX2(BLI_rcti_size_y(&rotate_canvas_), max_scale_canvas_size_.y)};
ScaleOperation::clamp_area_size_max(scale_canvas_, max_scale_size);
r_area = scale_canvas_;
}
}
}
/** Translate -> Rotate -> Scale. */
void TransformOperation::transform(BuffersIterator<float> &it, const MemoryBuffer *input_img)
{
float rotate_center_x, rotate_center_y;
RotateOperation::get_rotation_center(translate_canvas_, rotate_center_x, rotate_center_y);
float rotate_offset_x, rotate_offset_y;
RotateOperation::get_rotation_offset(
translate_canvas_, rotate_canvas_, rotate_offset_x, rotate_offset_y);
const float scale_center_x = BLI_rcti_size_x(&rotate_canvas_) / 2.0f;
const float scale_center_y = BLI_rcti_size_y(&rotate_canvas_) / 2.0f;
float scale_offset_x, scale_offset_y;
ScaleOperation::get_scale_offset(rotate_canvas_, scale_canvas_, scale_offset_x, scale_offset_y);
for (; !it.is_end(); ++it) {
float x = ScaleOperation::scale_coord_inverted(it.x + scale_offset_x, scale_center_x, scale_);
float y = ScaleOperation::scale_coord_inverted(it.y + scale_offset_y, scale_center_y, scale_);
x = rotate_offset_x + x;
y = rotate_offset_y + y;
RotateOperation::rotate_coords(
x, y, rotate_center_x, rotate_center_y, rotate_sine_, rotate_cosine_);
input_img->read_elem_sampled(x - translate_x_, y - translate_y_, sampler_, it.out);
}
}
/** Scale -> Rotate -> Translate. */
void TransformOperation::transform_inverted(BuffersIterator<float> &it,
const MemoryBuffer *input_img)
{
const rcti &image_canvas = get_input_operation(IMAGE_INPUT_INDEX)->get_canvas();
const float scale_center_x = BLI_rcti_size_x(&image_canvas) / 2.0f - translate_x_;
const float scale_center_y = BLI_rcti_size_y(&image_canvas) / 2.0f - translate_y_;
float scale_offset_x, scale_offset_y;
ScaleOperation::get_scale_offset(image_canvas, scale_canvas_, scale_offset_x, scale_offset_y);
float rotate_center_x, rotate_center_y;
RotateOperation::get_rotation_center(translate_canvas_, rotate_center_x, rotate_center_y);
rotate_center_x -= translate_x_;
rotate_center_y -= translate_y_;
float rotate_offset_x, rotate_offset_y;
RotateOperation::get_rotation_offset(
scale_canvas_, rotate_canvas_, rotate_offset_x, rotate_offset_y);
for (; !it.is_end(); ++it) {
float x = rotate_offset_x + (it.x - translate_x_);
float y = rotate_offset_y + (it.y - translate_y_);
RotateOperation::rotate_coords(
x, y, rotate_center_x, rotate_center_y, rotate_sine_, rotate_cosine_);
x = ScaleOperation::scale_coord_inverted(x + scale_offset_x, scale_center_x, scale_);
y = ScaleOperation::scale_coord_inverted(y + scale_offset_y, scale_center_y, scale_);
input_img->read_elem_sampled(x, y, sampler_, it.out);
}
}
} // namespace blender::compositor
Reference in New Issue View Git Blame Copy Permalink