← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/blender/blenlib/intern/jitter.c

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/blenlib/intern/jitter.c
1
1
/*
2
 
 * Jitter offset table
3
 
 *
4
 
 *
5
2
 * ***** BEGIN GPL LICENSE BLOCK *****
6
3
 *
7
4
 * This program is free software; you can redistribute it and/or
30
27
 
31
28
/** \file blender/blenlib/intern/jitter.c
32
29
 *  \ingroup bli
 
30
 *  \brief Jitter offset table
33
31
 */
34
32
 
35
 
 
36
33
#include <math.h>
37
34
#include <string.h>
38
35
#include "MEM_guardedalloc.h"
43
40
 
44
41
void BLI_jitterate1(float *jit1, float *jit2, int num, float rad1)
45
42
{
46
 
        int i , j , k;
 
43
        int i, j, k;
47
44
        float vecx, vecy, dvecx, dvecy, x, y, len;
48
45
 
49
 
        for (i = 2*num-2; i>=0 ; i-=2) {
 
46
        for (i = 2 * num - 2; i >= 0; i -= 2) {
50
47
                dvecx = dvecy = 0.0;
51
48
                x = jit1[i];
52
 
                y = jit1[i+1];
53
 
                for (j = 2*num-2; j>=0 ; j-=2) {
 
49
                y = jit1[i + 1];
 
50
                for (j = 2 * num - 2; j >= 0; j -= 2) {
54
51
                        if (i != j) {
55
52
                                vecx = jit1[j] - x - 1.0f;
56
 
                                vecy = jit1[j+1] - y - 1.0f;
57
 
                                for (k = 3; k>0 ; k--) {
58
 
                                        if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
59
 
                                                len=  sqrt(vecx*vecx + vecy*vecy);
60
 
                                                if (len>0 && len<rad1) {
61
 
                                                        len= len/rad1;
62
 
                                                        dvecx += vecx/len;
63
 
                                                        dvecy += vecy/len;
64
 
                                                }
65
 
                                        }
66
 
                                        vecx += 1.0f;
67
 
 
68
 
                                        if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
69
 
                                                len=  sqrt(vecx*vecx + vecy*vecy);
70
 
                                                if (len>0 && len<rad1) {
71
 
                                                        len= len/rad1;
72
 
                                                        dvecx += vecx/len;
73
 
                                                        dvecy += vecy/len;
74
 
                                                }
75
 
                                        }
76
 
                                        vecx += 1.0f;
77
 
 
78
 
                                        if ( fabsf(vecx)<rad1 && fabsf(vecy)<rad1) {
79
 
                                                len=  sqrt(vecx*vecx + vecy*vecy);
80
 
                                                if (len>0 && len<rad1) {
81
 
                                                        len= len/rad1;
82
 
                                                        dvecx += vecx/len;
83
 
                                                        dvecy += vecy/len;
 
53
                                vecy = jit1[j + 1] - y - 1.0f;
 
54
                                for (k = 3; k > 0; k--) {
 
55
                                        if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
 
56
                                                len =  sqrt(vecx * vecx + vecy * vecy);
 
57
                                                if (len > 0 && len < rad1) {
 
58
                                                        len = len / rad1;
 
59
                                                        dvecx += vecx / len;
 
60
                                                        dvecy += vecy / len;
 
61
                                                }
 
62
                                        }
 
63
                                        vecx += 1.0f;
 
64
 
 
65
                                        if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
 
66
                                                len =  sqrt(vecx * vecx + vecy * vecy);
 
67
                                                if (len > 0 && len < rad1) {
 
68
                                                        len = len / rad1;
 
69
                                                        dvecx += vecx / len;
 
70
                                                        dvecy += vecy / len;
 
71
                                                }
 
72
                                        }
 
73
                                        vecx += 1.0f;
 
74
 
 
75
                                        if (fabsf(vecx) < rad1 && fabsf(vecy) < rad1) {
 
76
                                                len =  sqrt(vecx * vecx + vecy * vecy);
 
77
                                                if (len > 0 && len < rad1) {
 
78
                                                        len = len / rad1;
 
79
                                                        dvecx += vecx / len;
 
80
                                                        dvecy += vecy / len;
84
81
                                                }
85
82
                                        }
86
83
                                        vecx -= 2.0f;
89
86
                        }
90
87
                }
91
88
 
92
 
                x -= dvecx/18.0f;
93
 
                y -= dvecy/18.0f;
 
89
                x -= dvecx / 18.0f;
 
90
                y -= dvecy / 18.0f;
94
91
                x -= floorf(x);
95
92
                y -= floorf(y);
96
93
                jit2[i] = x;
97
 
                jit2[i+1] = y;
 
94
                jit2[i + 1] = y;
98
95
        }
99
 
        memcpy(jit1,jit2,2 * num * sizeof(float));
 
96
        memcpy(jit1, jit2, 2 * num * sizeof(float));
100
97
}
101
98
 
102
99
void BLI_jitterate2(float *jit1, float *jit2, int num, float rad2)
104
101
        int i, j;
105
102
        float vecx, vecy, dvecx, dvecy, x, y;
106
103
 
107
 
        for (i=2*num -2; i>= 0 ; i-=2) {
 
104
        for (i = 2 * num - 2; i >= 0; i -= 2) {
108
105
                dvecx = dvecy = 0.0;
109
106
                x = jit1[i];
110
 
                y = jit1[i+1];
111
 
                for (j =2*num -2; j>= 0 ; j-=2) {
 
107
                y = jit1[i + 1];
 
108
                for (j = 2 * num - 2; j >= 0; j -= 2) {
112
109
                        if (i != j) {
113
110
                                vecx = jit1[j] - x - 1.0f;
114
 
                                vecy = jit1[j+1] - y - 1.0f;
115
 
 
116
 
                                if ( fabsf(vecx)<rad2) dvecx+= vecx*rad2;
117
 
                                vecx += 1.0f;
118
 
                                if ( fabsf(vecx)<rad2) dvecx+= vecx*rad2;
119
 
                                vecx += 1.0f;
120
 
                                if ( fabsf(vecx)<rad2) dvecx+= vecx*rad2;
121
 
 
122
 
                                if ( fabsf(vecy)<rad2) dvecy+= vecy*rad2;
123
 
                                vecy += 1.0f;
124
 
                                if ( fabsf(vecy)<rad2) dvecy+= vecy*rad2;
125
 
                                vecy += 1.0f;
126
 
                                if ( fabsf(vecy)<rad2) dvecy+= vecy*rad2;
 
111
                                vecy = jit1[j + 1] - y - 1.0f;
 
112
 
 
113
                                if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
 
114
                                vecx += 1.0f;
 
115
                                if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
 
116
                                vecx += 1.0f;
 
117
                                if (fabsf(vecx) < rad2) dvecx += vecx * rad2;
 
118
 
 
119
                                if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
 
120
                                vecy += 1.0f;
 
121
                                if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
 
122
                                vecy += 1.0f;
 
123
                                if (fabsf(vecy) < rad2) dvecy += vecy * rad2;
127
124
 
128
125
                        }
129
126
                }
130
127
 
131
 
                x -= dvecx/2.0f;
132
 
                y -= dvecy/2.0f;
 
128
                x -= dvecx / 2.0f;
 
129
                y -= dvecy / 2.0f;
133
130
                x -= floorf(x);
134
131
                y -= floorf(y);
135
132
                jit2[i] = x;
136
 
                jit2[i+1] = y;
 
133
                jit2[i + 1] = y;
137
134
        }
138
 
        memcpy(jit1,jit2,2 * num * sizeof(float));
 
135
        memcpy(jit1, jit2, 2 * num * sizeof(float));
139
136
}
140
137
 
141
138
 
142
 
void BLI_initjit(float *jitarr, int num)
 
139
void BLI_jitter_init(float *jitarr, int num)
143
140
{
144
141
        float *jit2, x, rad1, rad2, rad3;
145
142
        int i;
146
143
 
147
 
        if (num==0) return;
 
144
        if (num == 0) return;
148
145
 
149
 
        jit2= MEM_mallocN(12 + 2*sizeof(float)*num, "initjit");
150
 
        rad1= 1.0f/sqrtf((float)num);
151
 
        rad2= 1.0f/((float)num);
152
 
        rad3= sqrtf((float)num)/((float)num);
 
146
        jit2 = MEM_mallocN(12 + 2 * sizeof(float) * num, "initjit");
 
147
        rad1 = 1.0f / sqrtf((float)num);
 
148
        rad2 = 1.0f / ((float)num);
 
149
        rad3 = sqrtf((float)num) / ((float)num);
153
150
 
154
151
        BLI_srand(31415926 + num);
155
 
        x= 0;
156
 
        for (i=0; i<2*num; i+=2) {
157
 
                jitarr[i]= x+ rad1*(float)(0.5-BLI_drand());
158
 
                jitarr[i+1]= ((float)i/2)/num +rad1*(float)(0.5-BLI_drand());
159
 
                x+= rad3;
 
152
        x = 0;
 
153
        for (i = 0; i < 2 * num; i += 2) {
 
154
                jitarr[i] = x + rad1 * (float)(0.5 - BLI_drand());
 
155
                jitarr[i + 1] = ((float)i / 2) / num + rad1 * (float)(0.5 - BLI_drand());
 
156
                x += rad3;
160
157
                x -= floorf(x);
161
158
        }
162
159
 
163
 
        for (i=0 ; i<24 ; i++) {
 
160
        for (i = 0; i < 24; i++) {
164
161
                BLI_jitterate1(jitarr, jit2, num, rad1);
165
162
                BLI_jitterate1(jitarr, jit2, num, rad1);
166
163
                BLI_jitterate2(jitarr, jit2, num, rad2);
168
165
 
169
166
        MEM_freeN(jit2);
170
167
        
171
 
        /* finally, move jittertab to be centered around (0,0) */
172
 
        for (i=0; i<2*num; i+=2) {
 
168
        /* finally, move jittertab to be centered around (0, 0) */
 
169
        for (i = 0; i < 2 * num; i += 2) {
173
170
                jitarr[i] -= 0.5f;
174
 
                jitarr[i+1] -= 0.5f;
 
171
                jitarr[i + 1] -= 0.5f;
175
172
        }
176
173
        
177
174
}