[Bf-blender-cvs] SVN commit: /data/svn/bf-blender [48786] trunk/blender: some code refactors in raskter. c to sync it with build where mask tiling is being developed.

Peter Larabell xgl.asyliax at gmail.com
Tue Jul 10 06:51:11 CEST 2012


Revision: 48786
          http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=48786
Author:   xglasyliax
Date:     2012-07-10 04:51:08 +0000 (Tue, 10 Jul 2012)
Log Message:
-----------
some code refactors in raskter.c to sync it with build where mask tiling is being developed. Also adds a bit more mask tiling code.

Modified Paths:
--------------
    trunk/blender/intern/raskter/raskter.c
    trunk/blender/intern/raskter/raskter.h
    trunk/blender/intern/raskter/raskter_mt.c
    trunk/blender/source/blender/blenkernel/BKE_mask.h
    trunk/blender/source/blender/blenkernel/intern/mask.c
    trunk/blender/source/blender/compositor/operations/COM_MaskOperation.h

Modified: trunk/blender/intern/raskter/raskter.c
===================================================================
--- trunk/blender/intern/raskter/raskter.c	2012-07-10 04:43:23 UTC (rev 48785)
+++ trunk/blender/intern/raskter/raskter.c	2012-07-10 04:51:08 UTC (rev 48786)
@@ -814,14 +814,14 @@
     return (int)((normalized_value * (float)(max_value)) + 0.5f);
 }
 
-float get_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y) {
+inline float get_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y) {
     if(pos_x < 0 || pos_x >= buf_x || pos_y < 0 || pos_y >= buf_y) {
         return 0.0f;
     }
     return buf[(pos_y * buf_x) + pos_x];
 }
 
-float get_pixel_intensity_bilinear(float *buf, int buf_x, int buf_y, float u, float v) {
+inline float get_pixel_intensity_bilinear(float *buf, int buf_x, int buf_y, float u, float v) {
     int a;
     int b;
     int a_plus_1;
@@ -847,7 +847,7 @@
 
 }
 
-void set_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y, float intensity) {
+inline void set_pixel_intensity(float *buf, int buf_x, int buf_y, int pos_x, int pos_y, float intensity) {
     if(pos_x < 0 || pos_x >= buf_x || pos_y < 0 || pos_y >= buf_y) {
         return;
     }
@@ -869,114 +869,114 @@
     (void)buf;
     return 1;
 #else
-    const float p0 = 1.0f;
-    const float p1 = 1.0f;
-    const float p2 = 1.0f;
-    const float p3 = 1.0f;
-    const float p4 = 1.0f;
-    const float p5 = 1.5f;
-    const float p6 = 2.0f;
-    const float p7 = 2.0f;
-    const float p8 = 2.0f;
-    const float p9 = 2.0f;
-    const float p10 = 4.0f;
-    const float p11 = 8.0f;
+    const float jump01 = 1.0f;
+    const float jump02 = 1.0f;
+    const float jump03 = 1.0f;
+    const float jump04 = 1.0f;
+    const float jump05 = 1.0f;
+    const float jump06 = 1.5f;
+    const float jump07 = 2.0f;
+    const float jump08 = 2.0f;
+    const float jump09 = 2.0f;
+    const float jump10 = 2.0f;
+    const float jump11 = 4.0f;
+    const float jump12 = 8.0f;
 
     const float edge_threshold = 0.063f;
     const float edge_threshold_min = 0.0312f;
     const float quality_subpix = 1.0f;
 
-    float posM_x,posM_y;
-    float posB_x,posB_y;
-    float posN_x,posN_y;
-    float posP_x,posP_y;
-    float offNP_x,offNP_y;
-    float lumaM;
-    float lumaS;
-    float lumaE;
-    float lumaN;
-    float lumaW;
-    float lumaNW;
-    float lumaSE;
-    float lumaNE;
-    float lumaSW;
-    float lumaNS;
-    float lumaWE;
-    float lumaNESE;
-    float lumaNWNE;
-    float lumaNWSW;
-    float lumaSWSE;
-    float lumaNN;
-    float lumaSS;
-    float lumaEndN;
-    float lumaEndP;
-    float lumaMM;
-    float lumaMLTZero;
-    float subpixNWSWNESE;
-    float subpixRcpRange;
-    float subpixNSWE;
-    float maxSM;
-    float minSM;
-    float maxESM;
-    float minESM;
-    float maxWN;
-    float minWN;
-    float rangeMax;
-    float rangeMin;
-    float rangeMaxScaled;
-    float range;
-    float rangeMaxClamped;
-    float edgeHorz;
-    float edgeVert;
-    float edgeHorz1;
-    float edgeVert1;
-    float edgeHorz2;
-    float edgeVert2;
-    float edgeHorz3;
-    float edgeVert3;
-    float edgeHorz4;
-    float edgeVert4;
-    float lengthSign;
-    float subpixA;
-    float subpixB;
-    float subpixC;
-    float subpixD;
-    float subpixE;
-    float subpixF;
-    float subpixG;
-    float subpixH;
-    float gradientN;
-    float gradientS;
-    float gradient;
-    float gradientScaled;
-    float dstN;
-    float dstP;
+    float fpcx,fpcy;
+    float fpsqx,fpsqy;
+    float fprevx,fprevy;
+    float fpfowx,fpfowy;
+    float offset_dgx,offset_dgy;
+    float pci;
+    float pdi;
+    float pri;
+    float pui;
+    float pli;
+    float uli;
+    float dri;
+    float uri;
+    float dli;
+    float udi;
+    float lri;
+    float fsi;
+    float ti;
+    float cdi;
+    float bi;
+    float uui;
+    float ddi;
+    float eri;
+    float efi;
+    float cci;
+    float ltz;
+    float spX;
+    float inv_r;
+    float spP;
+    float gdc;
+    float sdc;
+    float gedc;
+    float sedc;
+    float glu;
+    float slu;
+    float gr;
+    float sr;
+    float grexp;
+    float r;
+    float grc;
+    float lre;
+    float ude;
+    float lre0;
+    float ude0;
+    float lre1;
+    float ude1;
+    float lre2;
+    float ude2;
+    float lre3;
+    float ude3;
+    float sdst;
+    float tg0;
+    float tg1;
+    float tg2;
+    float tg3;
+    float tg4;
+    float tg5;
+    float tg6;
+    float tg7;
+    float ugrad;
+    float dgrad;
+    float grad;
+    float gradexp;
+    float revdst;
+    float fowdst;
     float dst;
-    float spanLength;
-    float spanLengthRcp;
-    float pixelOffset;
-    float pixelOffsetGood;
-    float pixelOffsetSubpix;
+    float dsts;
+    float inv_dsts;
+    float pxOff;
+    float gpxOff;
+    float tgpxOff;
     float opx;
     float opy;
-    int directionN;
-    int goodSpan;
-    int goodSpanN;
-    int goodSpanP;
-    int horzSpan;
-    int earlyExit;
-    int pairN;
-    int doneN;
-    int doneP;
-    int doneNP;
+    int uls;
+    int sph;
+    int revsph;
+    int fowsph;
+    int lrsp;
+    int done;
+    int revpp;
+    int revdone;
+    int fowdone;
+    int tug_of_war;
     int curr_x=0;
     int curr_y=0;
     opx = (1.0f / (float)(buf_x));
     opy = (1.0f / (float)(buf_y));
     for(curr_y=0; curr_y < buf_y; curr_y++) {
         for(curr_x=0; curr_x < buf_x; curr_x++) {
-            posM_x = ((float)(curr_x) + 0.5f) * opx;
-            posM_y = ((float)(curr_y) + 0.5f) * opy;
+            fpcx = ((float)(curr_x) + 0.5f) * opx;
+            fpcy = ((float)(curr_y) + 0.5f) * opy;
 //#define __PLX_BILINEAR_INITIAL_SAMPLES__ 1
 #ifdef __PLX_BILINEAR_INITIAL_SAMPLES__
             lumaM = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x, posM_y);
@@ -985,359 +985,359 @@
             lumaN = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x, posM_y - opy);
             lumaW = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x - opx, posM_y);
 #else
-    lumaM = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y);
-    lumaS = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y + 1);
-    lumaE = get_pixel_intensity(buf, buf_x, buf_y, curr_x + 1, curr_y);
-    lumaN = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y - 1);
-    lumaW = get_pixel_intensity(buf, buf_x, buf_y, curr_x - 1, curr_y);
+    pci = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y);
+    pdi = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y + 1);
+    pri = get_pixel_intensity(buf, buf_x, buf_y, curr_x + 1, curr_y);
+    pui = get_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y - 1);
+    pli = get_pixel_intensity(buf, buf_x, buf_y, curr_x - 1, curr_y);
 #endif
-            maxSM = MAX2(lumaS, lumaM);
-            minSM = MIN2(lumaS, lumaM);
-            maxESM = MAX2(lumaE, maxSM);
-            minESM = MIN2(lumaE, minSM);
-            maxWN = MAX2(lumaN, lumaW);
-            minWN = MIN2(lumaN, lumaW);
-            rangeMax = MAX2(maxWN, maxESM);
-            rangeMin = MIN2(minWN, minESM);
-            rangeMaxScaled = rangeMax * edge_threshold;
-            range = rangeMax - rangeMin;
-            rangeMaxClamped = MAX2(edge_threshold_min, rangeMaxScaled);
+            gdc = MAX2(pdi, pci);
+            sdc = MIN2(pdi, pci);
+            gedc = MAX2(pri, gdc);
+            sedc = MIN2(pri, sdc);
+            glu = MAX2(pui, pli);
+            slu = MIN2(pui, pli);
+            gr = MAX2(glu, gedc);
+            sr = MIN2(slu, sedc);
+            grexp = gr * edge_threshold;
+            r = gr - sr;
+            grc = MAX2(edge_threshold_min, grexp);
 
-            earlyExit = range < rangeMaxClamped ? 1:0;
-            if(earlyExit) {
-                set_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y, lumaM);
+            done = r < grc ? 1:0;
+            if(done) {
+                set_pixel_intensity(buf, buf_x, buf_y, curr_x, curr_y, pci);
             } else {
 
-                lumaNW = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x - opx, posM_y - opy);
-                lumaSE = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x + opx, posM_y + opy);
-                lumaNE = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x + opx, posM_y - opy);
-                lumaSW = get_pixel_intensity_bilinear(buf, buf_x, buf_y, posM_x - opx, posM_y + opy);
+                uli = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx - opx, fpcy - opy);
+                dri = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx + opx, fpcy + opy);
+                uri = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx + opx, fpcy - opy);
+                dli = get_pixel_intensity_bilinear(buf, buf_x, buf_y, fpcx - opx, fpcy + opy);
 
-                lumaNS = lumaN + lumaS;
-                lumaWE = lumaW + lumaE;
-                subpixRcpRange = 1.0f/range;
-                subpixNSWE = lumaNS + lumaWE;
-                edgeHorz1 = (-2.0f * lumaM) + lumaNS;
-                edgeVert1 = (-2.0f * lumaM) + lumaWE;
+                udi = pui + pdi;
+                lri = pli + pri;
+                inv_r = 1.0f/r;
+                spP = udi + lri;
+                lre0 = (-2.0f * pci) + udi;
+                ude0 = (-2.0f * pci) + lri;
 
-                lumaNESE = lumaNE + lumaSE;
-                lumaNWNE = lumaNW + lumaNE;
-                edgeHorz2 = (-2.0f * lumaE) + lumaNESE;
-                edgeVert2 = (-2.0f * lumaN) + lumaNWNE;
+                fsi = uri + dri;
+                ti = uli + uri;
+                lre1 = (-2.0f * pri) + fsi;
+                ude1 = (-2.0f * pui) + ti;
 
-                lumaNWSW = lumaNW + lumaSW;
-                lumaSWSE = lumaSW + lumaSE;
-                edgeHorz4 = (ABS(edgeHorz1) * 2.0f) + ABS(edgeHorz2);
-                edgeVert4 = (ABS(edgeVert1) * 2.0f) + ABS(edgeVert2);
-                edgeHorz3 = (-2.0f * lumaW) + lumaNWSW;
-                edgeVert3 = (-2.0f * lumaS) + lumaSWSE;
-                edgeHorz = ABS(edgeHorz3) + edgeHorz4;
-                edgeVert = ABS(edgeVert3) + edgeVert4;
+                cdi = uli + dli;
+                bi = dli + dri;
+                lre3 = (ABS(lre0) * 2.0f) + ABS(lre1);
+                ude3 = (ABS(ude0) * 2.0f) + ABS(ude1);
+                lre2 = (-2.0f * pli) + cdi;
+                ude2 = (-2.0f * pdi) + bi;
+                lre = ABS(lre2) + lre3;
+                ude = ABS(ude2) + ude3;
 

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list