source/blender/editors/armature/editarmature_generate.c

   1 /**
   2  * $Id: editarmature_generate.c  $
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (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 Foundation,
  18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): none yet.
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  * editarmature.c: Interface for creating and posing armature objects
  29  */
  30
  31 #include <string.h>
  32 #include <math.h>
  33
  34 #include "MEM_guardedalloc.h"
  35
  36 #include "DNA_listBase.h"
  37 #include "DNA_scene_types.h"
  38 #include "DNA_armature_types.h"
  39
  40 #include "BLI_blenlib.h"
  41 #include "BLI_arithb.h"
  42 #include "BLI_graph.h"
  43
  44 #include "BKE_utildefines.h"
  45 #include "BKE_global.h"
  46 #include "BKE_context.h"
  47
  48 #include "ED_armature.h"
  49 #include "BIF_generate.h"
  50
  51 void setBoneRollFromNormal(EditBone *bone, float *no, float invmat[][4], float tmat[][3])
  52 {
  53         if (no != NULL && !VecIsNull(no))
  54         {
  55                 float tangent[3], cotangent[3], normal[3];
  56
  57                 VECCOPY(normal, no);
  58                 Mat3MulVecfl(tmat, normal);
  59
  60                 VecSubf(tangent, bone->tail, bone->head);
  61                 Crossf(cotangent, tangent, normal);
  62                 Crossf(normal, cotangent, tangent);
  63
  64                 Normalize(normal);
  65
  66                 bone->roll = ED_rollBoneToVector(bone, normal);
  67         }
  68 }
  69
  70 float calcArcCorrelation(BArcIterator *iter, int start, int end, float v0[3], float n[3])
  71 {
  72         int len = 2 + abs(end - start);
  73
  74         if (len > 2)
  75         {
  76                 float avg_t = 0.0f;
  77                 float s_t = 0.0f;
  78                 float s_xyz = 0.0f;
  79                 int i;
  80
  81                 /* First pass, calculate average */
  82                 for (i = start; i <= end; i++)
  83                 {
  84                         float v[3];
  85
  86                         IT_peek(iter, i);
  87                         VecSubf(v, iter->p, v0);
  88                         avg_t += Inpf(v, n);
  89                 }
  90
  91                 avg_t /= Inpf(n, n);
  92                 avg_t += 1.0f; /* adding start (0) and end (1) values */
  93                 avg_t /= len;
  94
  95                 /* Second pass, calculate s_xyz and s_t */
  96                 for (i = start; i <= end; i++)
  97                 {
  98                         float v[3], d[3];
  99                         float dt;
 100
 101                         IT_peek(iter, i);
 102                         VecSubf(v, iter->p, v0);
 103                         Projf(d, v, n);
 104                         VecSubf(v, v, d);
 105
 106                         dt = VecLength(d) - avg_t;
 107
 108                         s_t += dt * dt;
 109                         s_xyz += Inpf(v, v);
 110                 }
 111
 112                 /* adding start(0) and end(1) values to s_t */
 113                 s_t += (avg_t * avg_t) + (1 - avg_t) * (1 - avg_t);
 114
 115                 return 1.0f - s_xyz / s_t;
 116         }
 117         else
 118         {
 119                 return 1.0f;
 120         }
 121 }
 122
 123 int nextFixedSubdivision(bContext *C, BArcIterator *iter, int start, int end, float head[3], float p[3])
 124 {
 125         static float stroke_length = 0;
 126         static float current_length;
 127         static char n;
 128         Scene *scene = CTX_data_scene(C);
 129         float *v1, *v2;
 130         float length_threshold;
 131         int i;
 132
 133         if (stroke_length == 0)
 134         {
 135                 current_length = 0;
 136
 137                 IT_peek(iter, start);
 138                 v1 = iter->p;
 139
 140                 for (i = start + 1; i <= end; i++)
 141                 {
 142                         IT_peek(iter, i);
 143                         v2 = iter->p;
 144
 145                         stroke_length += VecLenf(v1, v2);
 146
 147                         v1 = v2;
 148                 }
 149
 150                 n = 0;
 151                 current_length = 0;
 152         }
 153
 154         n++;
 155
 156         length_threshold = n * stroke_length / scene->toolsettings->skgen_subdivision_number;
 157
 158         IT_peek(iter, start);
 159         v1 = iter->p;
 160
 161         /* < and not <= because we don't care about end, it is P_EXACT anyway */
 162         for (i = start + 1; i < end; i++)
 163         {
 164                 IT_peek(iter, i);
 165                 v2 = iter->p;
 166
 167                 current_length += VecLenf(v1, v2);
 168
 169                 if (current_length >= length_threshold)
 170                 {
 171                         VECCOPY(p, v2);
 172                         return i;
 173                 }
 174
 175                 v1 = v2;
 176         }
 177
 178         stroke_length = 0;
 179
 180         return -1;
 181 }
 182 int nextAdaptativeSubdivision(bContext *C, BArcIterator *iter, int start, int end, float head[3], float p[3])
 183 {
 184         Scene *scene = CTX_data_scene(C);
 185         float correlation_threshold = scene->toolsettings->skgen_correlation_limit;
 186         float *start_p;
 187         float n[3];
 188         int i;
 189
 190         IT_peek(iter, start);
 191         start_p = iter->p;
 192
 193         for (i = start + 2; i <= end; i++)
 194         {
 195                 /* Calculate normal */
 196                 IT_peek(iter, i);
 197                 VecSubf(n, iter->p, head);
 198
 199                 if (calcArcCorrelation(iter, start, i, start_p, n) < correlation_threshold)
 200                 {
 201                         IT_peek(iter, i - 1);
 202                         VECCOPY(p, iter->p);
 203                         return i - 1;
 204                 }
 205         }
 206
 207         return -1;
 208 }
 209
 210 int nextLengthSubdivision(bContext *C, BArcIterator *iter, int start, int end, float head[3], float p[3])
 211 {
 212         Scene *scene = CTX_data_scene(C);
 213         float lengthLimit = scene->toolsettings->skgen_length_limit;
 214         int same = 1;
 215         int i;
 216
 217         i = start + 1;
 218         while (i <= end)
 219         {
 220                 float *vec0;
 221                 float *vec1;
 222
 223                 IT_peek(iter, i - 1);
 224                 vec0 = iter->p;
 225
 226                 IT_peek(iter, i);
 227                 vec1 = iter->p;
 228
 229                 /* If lengthLimit hits the current segment */
 230                 if (VecLenf(vec1, head) > lengthLimit)
 231                 {
 232                         if (same == 0)
 233                         {
 234                                 float dv[3], off[3];
 235                                 float a, b, c, f;
 236
 237                                 /* Solve quadratic distance equation */
 238                                 VecSubf(dv, vec1, vec0);
 239                                 a = Inpf(dv, dv);
 240
 241                                 VecSubf(off, vec0, head);
 242                                 b = 2 * Inpf(dv, off);
 243
 244                                 c = Inpf(off, off) - (lengthLimit * lengthLimit);
 245
 246                                 f = (-b + (float)sqrt(b * b - 4 * a * c)) / (2 * a);
 247
 248                                 //printf("a %f, b %f, c %f, f %f\n", a, b, c, f);
 249
 250                                 if (isnan(f) == 0 && f < 1.0f)
 251                                 {
 252                                         VECCOPY(p, dv);
 253                                         VecMulf(p, f);
 254                                         VecAddf(p, p, vec0);
 255                                 }
 256                                 else
 257                                 {
 258                                         VECCOPY(p, vec1);
 259                                 }
 260                         }
 261                         else
 262                         {
 263                                 float dv[3];
 264
 265                                 VecSubf(dv, vec1, vec0);
 266                                 Normalize(dv);
 267
 268                                 VECCOPY(p, dv);
 269                                 VecMulf(p, lengthLimit);
 270                                 VecAddf(p, p, head);
 271                         }
 272
 273                         return i - 1; /* restart at lower bound */
 274                 }
 275                 else
 276                 {
 277                         i++;
 278                         same = 0; // Reset same
 279                 }
 280         }
 281
 282         return -1;
 283 }
 284
 285 EditBone * subdivideArcBy(bContext *C, bArmature *arm, ListBase *editbones, BArcIterator *iter, float invmat[][4], float tmat[][3], NextSubdivisionFunc next_subdividion)
 286 {
 287         EditBone *lastBone = NULL;
 288         EditBone *child = NULL;
 289         EditBone *parent = NULL;
 290         int bone_start = 0;
 291         int end = iter->length;
 292         int index;
 293
 294         IT_head(iter);
 295
 296         parent = addEditBone(arm, "Bone");
 297         VECCOPY(parent->head, iter->p);
 298
 299         index = next_subdividion(C, iter, bone_start, end, parent->head, parent->tail);
 300         while (index != -1)
 301         {
 302                 IT_peek(iter, index);
 303
 304                 child = addEditBone(arm, "Bone");
 305                 VECCOPY(child->head, parent->tail);
 306                 child->parent = parent;
 307                 child->flag |= BONE_CONNECTED;
 308
 309                 /* going to next bone, fix parent */
 310                 Mat4MulVecfl(invmat, parent->tail);
 311                 Mat4MulVecfl(invmat, parent->head);
 312                 setBoneRollFromNormal(parent, iter->no, invmat, tmat);
 313
 314                 parent = child; // new child is next parent
 315                 bone_start = index; // start next bone from current index
 316
 317                 index = next_subdividion(C, iter, bone_start, end, parent->head, parent->tail);
 318         }
 319
 320         iter->tail(iter);
 321
 322         VECCOPY(parent->tail, iter->p);
 323
 324         /* fix last bone */
 325         Mat4MulVecfl(invmat, parent->tail);
 326         Mat4MulVecfl(invmat, parent->head);
 327         setBoneRollFromNormal(parent, iter->no, invmat, tmat);
 328         lastBone = parent;
 329
 330         return lastBone;
 331 }