cinelerra-5.1/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, float jm1, float j, float jp1, float jp2);
  78         AffineEngine *server;
  79 };
  80
  81 class AffineEngine : public LoadServer
  82 {
  83 public:
  84         AffineEngine(int total_clients,
  85                 int total_packages);
  86
  87 // Range of coords is 0 to 100 for coordinates in the image.
  88 // The coordinate locations are clockwise around the image.
  89         void process(VFrame *output,
  90                 VFrame *input,
  91                 VFrame *temp,
  92                 int mode,
  93                 float x1,
  94                 float y1,
  95                 float x2,
  96                 float y2,
  97                 float x3,
  98                 float y3,
  99                 float x4,
 100                 float y4,
 101                 int forward);
 102 // Do rotation with the affine/perspective transform.
 103 // This removes some of the extremely faint artifacts in the trig rotation.
 104         void rotate(VFrame *output,
 105                 VFrame *input,
 106                 float angle);
 107         void set_matrix(AffineMatrix *matrix);
 108 // Set the viewport to transform.  The transform is based on the input viewport.
 109 // The output viewport clips the transformed output.
 110         void set_in_viewport(int x, int y, int w, int h);
 111 // Only used by motion tracker.  Not used in OpenGL.
 112         void set_out_viewport(int x, int y, int w, int h);
 113
 114 // Set the viewport for both input and output.  Removed in HV 4.5.
 115 // Compatibility function introduced to avoid having to rewrite old
 116 // plugins.  Should be removed when no plugin uses it any more.
 117         void set_viewport(int x, int y, int w, int h);
 118 // For rotation, set the pivot point.  Also affects output in OpenGL.
 119 // The default is in the middle of the viewport.
 120         void set_in_pivot(int x, int y);
 121 // Set the pivot point in the output.  Only used by motion tracker.
 122         void set_out_pivot(int x, int y);
 123 // Set the pivot point for both input and output.  Removed in HV 4.5.
 124 // Compatibility function introduced to avoid having to rewrite old
 125 // plugins.
 126         void set_pivot(int x, int y);
 127 // Never used
 128         void unset_pivot();
 129         void unset_viewport();
 130 // To use OpenGL for the processing, set to 1
 131         void set_opengl(int value);
 132         void init_packages();
 133         LoadClient* new_client();
 134         LoadPackage* new_package();
 135
 136
 137         VFrame *input, *output, *temp;
 138         int mode;
 139         enum
 140         {
 141                 PERSPECTIVE,
 142                 SHEER,
 143                 STRETCH,
 144                 ROTATE,
 145 // multiply directly by a matrix.
 146                 TRANSFORM
 147         };
 148
 149 // arbitrary matrix
 150         AffineMatrix matrix;
 151 // Transformation coordinates
 152         float x1, y1, x2, y2, x3, y3, x4, y4;
 153 // Viewport coordinates
 154         int in_x, in_y, in_w, in_h;
 155         int out_x, out_y, out_w, out_h;
 156 // Pivot coordinates
 157         int in_pivot_x, in_pivot_y;
 158         int out_pivot_x, out_pivot_y;
 159         int user_in_pivot;
 160         int user_out_pivot;
 161         int user_in_viewport;
 162         int user_out_viewport;
 163         int forward;
 164         int use_opengl;
 165         int total_packages;
 166 };
 167
 168
 169
 170 #endif