cinelerra-5.0/cinelerra/affine.h

   1
   2 /*
   3  * CINELERRA
   4  * Copyright (C) 2008-2014 Adam Williams <broadcast at earthling dot net>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #ifndef AFFINE_H
  23 #define AFFINE_H
  24
  25
  26 #include "affine.inc"
  27 #include "loadbalance.h"
  28 #include "vframe.inc"
  29
  30 // Affine transform library
  31
  32 #define AFFINE_OVERSAMPLE 2
  33
  34 class AffineMatrix
  35 {
  36 public:
  37         AffineMatrix();
  38         void identity();
  39         void translate(double x, double y);
  40         void scale(double x, double y);
  41 // Result is put in dst
  42         void multiply(AffineMatrix *dst);
  43         void copy_from(AffineMatrix *src);
  44         void invert(AffineMatrix *dst);
  45         void transform_point(float x, float y, float *newx, float *newy);
  46         double determinant();
  47         void dump();
  48         double values[3][3];
  49 };
  50
  51 class AffinePackage : public LoadPackage
  52 {
  53 public:
  54         AffinePackage();
  55         int y1, y2;
  56 };
  57
  58 class AffineUnit : public LoadClient
  59 {
  60 public:
  61         AffineUnit(AffineEngine *server);
  62         void process_package(LoadPackage *package);
  63         void calculate_matrix(
  64                 double in_x1,
  65                 double in_y1,
  66                 double in_x2,
  67                 double in_y2,
  68                 double out_x1,
  69                 double out_y1,
  70                 double out_x2,
  71                 double out_y2,
  72                 double out_x3,
  73                 double out_y3,
  74                 double out_x4,
  75                 double out_y4,
  76                 AffineMatrix *result);
  77         float transform_cubic(float dx,
  78         float jm1,
  79         float j,
  80         float jp1,
  81         float jp2);
  82         AffineEngine *server;
  83 };
  84
  85 class AffineEngine : public LoadServer
  86 {
  87 public:
  88         AffineEngine(int total_clients,
  89                 int total_packages);
  90
  91 // Range of coords is 0 to 100 for coordinates in the image.
  92 // The coordinate locations are clockwise around the image.
  93         void process(VFrame *output,
  94                 VFrame *input,
  95                 VFrame *temp,
  96                 int mode,
  97                 float x1,
  98                 float y1,
  99                 float x2,
 100                 float y2,
 101                 float x3,
 102                 float y3,
 103                 float x4,
 104                 float y4,
 105                 int forward);
 106 // Do rotation with the affine/perspective transform.
 107 // This removes some of the extremely faint artifacts in the trig rotation.
 108         void rotate(VFrame *output,
 109                 VFrame *input,
 110                 float angle);
 111         void set_matrix(AffineMatrix *matrix);
 112 // Set the viewport to transform.  The transform is based on the input viewport.
 113 // The output viewport clips the transformed output.
 114         void set_in_viewport(int x, int y, int w, int h);
 115 // Only used by motion tracker.  Not used in OpenGL.
 116         void set_out_viewport(int x, int y, int w, int h);
 117 // For rotation, set the pivot point.  Also affects output in OpenGL.
 118 // The default is in the middle of the viewport.
 119         void set_in_pivot(int x, int y);
 120 // Set the pivot point in the output.  Only used by motion tracker.
 121         void set_out_pivot(int x, int y);
 122 // Never used
 123         void unset_pivot();
 124         void unset_viewport();
 125 // To use OpenGL for the processing, set to 1
 126         void set_opengl(int value);
 127         void init_packages();
 128         LoadClient* new_client();
 129         LoadPackage* new_package();
 130
 131
 132         VFrame *input, *output, *temp;
 133         int mode;
 134         enum
 135         {
 136                 PERSPECTIVE,
 137                 SHEER,
 138                 STRETCH,
 139                 ROTATE,
 140 // multiply directly by a matrix.
 141                 TRANSFORM
 142         };
 143
 144 // arbitrary matrix
 145         AffineMatrix matrix;
 146 // Transformation coordinates
 147         float x1, y1, x2, y2, x3, y3, x4, y4;
 148 // Viewport coordinates
 149         int in_x, in_y, in_w, in_h;
 150         int out_x, out_y, out_w, out_h;
 151 // Pivot coordinates
 152         int in_pivot_x, in_pivot_y;
 153         int out_pivot_x, out_pivot_y;
 154         int user_in_pivot;
 155         int user_out_pivot;
 156         int user_in_viewport;
 157         int user_out_viewport;
 158         int forward;
 159         int use_opengl;
 160         int total_packages;
 161 };
 162
 163
 164
 165 #endif