]> git.saurik.com Git - wxWidgets.git/blame - src/freetype/autohint/ahoptim.c
projects / wxWidgets.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
corrected dynamic class implementation
[wxWidgets.git] / src / freetype / autohint / ahoptim.c
CommitLineData
cabec872
RR		 1/***************************************************************************/
2/* */
3/* ahoptim.c */
4/* */
5/* FreeType auto hinting outline optimization (body). */
6/* */
7/* Copyright 2000 Catharon Productions Inc. */
8/* Author: David Turner */
9/* */
10/* This file is part of the Catharon Typography Project and shall only */
11/* be used, modified, and distributed under the terms of the Catharon */
12/* Open Source License that should come with this file under the name */
13/* `CatharonLicense.txt'. By continuing to use, modify, or distribute */
14/* this file you indicate that you have read the license and */
15/* understand and accept it fully. */
16/* */
17/* Note that this license is compatible with the FreeType license. */
18/* */
19/***************************************************************************/
20
21
22 /*************************************************************************/
23 /* */
24 /* This module is in charge of optimising the outlines produced by the */
25 /* auto-hinter in direct mode. This is required at small pixel sizes in */
26 /* order to ensure coherent spacing, among other things.. */
27 /* */
28 /* The technique used in this module is a simplified simulated */
29 /* annealing. */
30 /* */
31 /*************************************************************************/
32
33
34#include <freetype/internal/ftobjs.h> /* for ALLOC_ARRAY() and FREE() */
35
36
37#ifdef FT_FLAT_COMPILE
38
39#include "ahoptim.h"
40
41#else
42
43#include <autohint/ahoptim.h>
44
45#endif
46
47
48 /* define this macro to use brute force optimisation -- this is slow, */
49 /* but a good way to perfect the distortion function `by hand' through */
50 /* tweaking */
51#define AH_BRUTE_FORCE
52
53
54#define xxxAH_DEBUG_OPTIM
55
56
57#undef LOG
58#ifdef AH_DEBUG_OPTIM
59
60#define LOG( x ) optim_log##x
61
62#else
63
64#define LOG( x )
65
66#endif /* AH_DEBUG_OPTIM */
67
68
69#ifdef AH_DEBUG_OPTIM
70
71#include <stdarg.h>
72#include <stdlib.h>
73#include <string.h>
74
75#define FLOAT( x ) ( (float)( (x) / 64.0 ) )
76
77 static
78 void optim_log( const char* fmt, ... )
79 {
80 va_list ap;
81
82
83 va_start( ap, fmt );
84 vprintf( fmt, ap );
85 va_end( ap );
86 }
87
88
89 static
90 void AH_Dump_Stems( AH_Optimizer* optimizer )
91 {
92 int n;
93 AH_Stem* stem;
94
95
96 stem = optimizer->stems;
97 for ( n = 0; n < optimizer->num_stems; n++, stem++ )
98 {
99 LOG(( " %c%2d [%.1f:%.1f]={%.1f:%.1f}="
100 "<%1.f..%1.f> force=%.1f speed=%.1f\n",
101 optimizer->vertical ? 'V' : 'H', n,
102 FLOAT( stem->edge1->opos ), FLOAT( stem->edge2->opos ),
103 FLOAT( stem->edge1->pos ), FLOAT( stem->edge2->pos ),
104 FLOAT( stem->min_pos ), FLOAT( stem->max_pos ),
105 FLOAT( stem->force ), FLOAT( stem->velocity ) ));
106 }
107 }
108
109
110 static
111 void AH_Dump_Stems2( AH_Optimizer* optimizer )
112 {
113 int n;
114 AH_Stem* stem;
115
116
117 stem = optimizer->stems;
118 for ( n = 0; n < optimizer->num_stems; n++, stem++ )
119 {
120 LOG(( " %c%2d [%.1f]=<%1.f..%1.f> force=%.1f speed=%.1f\n",
121 optimizer->vertical ? 'V' : 'H', n,
122 FLOAT( stem->pos ),
123 FLOAT( stem->min_pos ), FLOAT( stem->max_pos ),
124 FLOAT( stem->force ), FLOAT( stem->velocity ) ));
125 }
126 }
127
128
129 static
130 void AH_Dump_Springs( AH_Optimizer* optimizer )
131 {
132 int n;
133 AH_Spring* spring;
134 AH_Stem* stems;
135
136
137 spring = optimizer->springs;
138 stems = optimizer->stems;
139 LOG(( "%cSprings ", optimizer->vertical ? 'V' : 'H' ));
140
141 for ( n = 0; n < optimizer->num_springs; n++, spring++ )
142 {
143 LOG(( " [%d-%d:%.1f:%1.f:%.1f]",
144 spring->stem1 - stems, spring->stem2 - stems,
145 FLOAT( spring->owidth ),
146 FLOAT( spring->stem2->pos -
147 ( spring->stem1->pos + spring->stem1->width ) ),
148 FLOAT( spring->tension ) ));
149 }
150
151 LOG(( "\n" ));
152 }
153
154#endif /* AH_DEBUG_OPTIM */
155
156
157 /*************************************************************************/
158 /*************************************************************************/
159 /*************************************************************************/
160 /**** ****/
161 /**** COMPUTE STEMS AND SPRINGS IN AN OUTLINE ****/
162 /**** ****/
163 /*************************************************************************/
164 /*************************************************************************/
165 /*************************************************************************/
166
167
168 static
169 int valid_stem_segments( AH_Segment* seg1,
170 AH_Segment* seg2 )
171 {
172 return seg1->serif == 0 &&
173 seg2 &&
174 seg2->link == seg1 &&
175 seg1->pos < seg2->pos &&
176 seg1->min_coord <= seg2->max_coord &&
177 seg2->min_coord <= seg1->max_coord;
178 }
179
180
181 /* compute all stems in an outline */
182 static
183 int optim_compute_stems( AH_Optimizer* optimizer )
184 {
185 AH_Outline* outline = optimizer->outline;
186 FT_Fixed scale;
187 FT_Memory memory = optimizer->memory;
188 FT_Error error = 0;
189 FT_Int dimension;
190 AH_Edge* edges;
191 AH_Edge* edge_limit;
192 AH_Stem** p_stems;
193 FT_Int* p_num_stems;
194
195
196 edges = outline->horz_edges;
197 edge_limit = edges + outline->num_hedges;
198 scale = outline->y_scale;
199
200 p_stems = &optimizer->horz_stems;
201 p_num_stems = &optimizer->num_hstems;
202
203 for ( dimension = 1; dimension >= 0; dimension-- )
204 {
205 AH_Stem* stems = 0;
206 FT_Int num_stems = 0;
207 AH_Edge* edge;
208
209
210 /* first of all, count the number of stems in this direction */
211 for ( edge = edges; edge < edge_limit; edge++ )
212 {
213 AH_Segment* seg = edge->first;
214
215
216 do
217 {
218 if (valid_stem_segments( seg, seg->link ) )
219 num_stems++;
220
221 seg = seg->edge_next;
222
223 } while ( seg != edge->first );
224 }
225
226 /* now allocate the stems and build their table */
227 if ( num_stems > 0 )
228 {
229 AH_Stem* stem;
230
231
232 if ( ALLOC_ARRAY( stems, num_stems, AH_Stem ) )
233 goto Exit;
234
235 stem = stems;
236 for ( edge = edges; edge < edge_limit; edge++ )
237 {
238 AH_Segment* seg = edge->first;
239 AH_Segment* seg2;
240
241
242 do
243 {
244 seg2 = seg->link;
245 if ( valid_stem_segments( seg, seg2 ) )
246 {
247 AH_Edge* edge1 = seg->edge;
248 AH_Edge* edge2 = seg2->edge;
249
250
251 stem->edge1 = edge1;
252 stem->edge2 = edge2;
253 stem->opos = edge1->opos;
254 stem->pos = edge1->pos;
255 stem->owidth = edge2->opos - edge1->opos;
256 stem->width = edge2->pos - edge1->pos;
257
258 /* compute min_coord and max_coord */
259 {
260 FT_Pos min_coord = seg->min_coord;
261 FT_Pos max_coord = seg->max_coord;
262
263
264 if ( seg2->min_coord > min_coord )
265 min_coord = seg2->min_coord;
266
267 if ( seg2->max_coord < max_coord )
268 max_coord = seg2->max_coord;
269
270 stem->min_coord = min_coord;
271 stem->max_coord = max_coord;
272 }
273
274 /* compute minimum and maximum positions for stem -- */
275 /* note that the left-most/bottom-most stem has always */
276 /* a fixed position */
277 if ( stem == stems || edge1->blue_edge || edge2->blue_edge )
278 {
279 /* this stem cannot move; it is snapped to a blue edge */
280 stem->min_pos = stem->pos;
281 stem->max_pos = stem->pos;
282 }
283 else
284 {
285 /* this edge can move; compute its min and max positions */
286 FT_Pos pos1 = stem->opos;
287 FT_Pos pos2 = pos1 + stem->owidth - stem->width;
288 FT_Pos min1 = pos1 & -64;
289 FT_Pos min2 = pos2 & -64;
290
291
292 stem->min_pos = min1;
293 stem->max_pos = min1 + 64;
294 if ( min2 < min1 )
295 stem->min_pos = min2;
296 else
297 stem->max_pos = min2 + 64;
298
299 /* XXX: just to see what it does */
300 stem->max_pos += 64;
301
302 /* just for the case where direct hinting did some */
303 /* incredible things (e.g. blue edge shifts) */
304 if ( stem->min_pos > stem->pos )
305 stem->min_pos = stem->pos;
306
307 if ( stem->max_pos < stem->pos )
308 stem->max_pos = stem->pos;
309 }
310
311 stem->velocity = 0;
312 stem->force = 0;
313
314 stem++;
315 }
316 seg = seg->edge_next;
317
318 } while ( seg != edge->first );
319 }
320 }
321
322 *p_stems = stems;
323 *p_num_stems = num_stems;
324
325 edges = outline->vert_edges;
326 edge_limit = edges + outline->num_vedges;
327 scale = outline->x_scale;
328
329 p_stems = &optimizer->vert_stems;
330 p_num_stems = &optimizer->num_vstems;
331 }
332
333 Exit:
334
335#ifdef AH_DEBUG_OPTIM
336 AH_Dump_Stems( optimizer );
337#endif
338
339 return error;
340 }
341
342
343 /* returns the spring area between two stems, 0 if none */
344 static
345 FT_Pos stem_spring_area( AH_Stem* stem1,
346 AH_Stem* stem2 )
347 {
348 FT_Pos area1 = stem1->max_coord - stem1->min_coord;
349 FT_Pos area2 = stem2->max_coord - stem2->min_coord;
350 FT_Pos min = stem1->min_coord;
351 FT_Pos max = stem1->max_coord;
352 FT_Pos area;
353
354
355 /* order stems */
356 if ( stem2->opos <= stem1->opos + stem1->owidth )
357 return 0;
358
359 if ( min < stem2->min_coord )
360 min = stem2->min_coord;
361
362 if ( max < stem2->max_coord )
363 max = stem2->max_coord;
364
365 area = ( max-min );
366 if ( 2 * area < area1 && 2 * area < area2 )
367 area = 0;
368
369 return area;
370 }
371
372
373 /* compute all springs in an outline */
374 static
375 int optim_compute_springs( AH_Optimizer* optimizer )
376 {
377 /* basically, a spring exists between two stems if most of their */
378 /* surface is aligned */
379 FT_Memory memory = optimizer->memory;
380
381 AH_Stem* stems;
382 AH_Stem* stem_limit;
383 AH_Stem* stem;
384 int dimension;
385 int error = 0;
386
387 FT_Int* p_num_springs;
388 AH_Spring** p_springs;
389
390
391 stems = optimizer->horz_stems;
392 stem_limit = stems + optimizer->num_hstems;
393
394 p_springs = &optimizer->horz_springs;
395 p_num_springs = &optimizer->num_hsprings;
396
397 for ( dimension = 1; dimension >= 0; dimension-- )
398 {
399 FT_Int num_springs = 0;
400 AH_Spring* springs = 0;
401
402
403 /* first of all, count stem springs */
404 for ( stem = stems; stem + 1 < stem_limit; stem++ )
405 {
406 AH_Stem* stem2;
407
408
409 for ( stem2 = stem+1; stem2 < stem_limit; stem2++ )
410 if ( stem_spring_area( stem, stem2 ) )
411 num_springs++;
412 }
413
414 /* then allocate and build the springs table */
415 if ( num_springs > 0 )
416 {
417 AH_Spring* spring;
418
419
420 /* allocate table of springs */
421 if ( ALLOC_ARRAY( springs, num_springs, AH_Spring ) )
422 goto Exit;
423
424 /* fill the springs table */
425 spring = springs;
426 for ( stem = stems; stem+1 < stem_limit; stem++ )
427 {
428 AH_Stem* stem2;
429 FT_Pos area;
430
431
432 for ( stem2 = stem + 1; stem2 < stem_limit; stem2++ )
433 {
434 area = stem_spring_area( stem, stem2 );
435 if ( area )
436 {
437 /* add a new spring here */
438 spring->stem1 = stem;
439 spring->stem2 = stem2;
440 spring->owidth = stem2->opos - ( stem->opos + stem->owidth );
441 spring->tension = 0;
442
443 spring++;
444 }
445 }
446 }
447 }
448 *p_num_springs = num_springs;
449 *p_springs = springs;
450
451 stems = optimizer->vert_stems;
452 stem_limit = stems + optimizer->num_vstems;
453
454 p_springs = &optimizer->vert_springs;
455 p_num_springs = &optimizer->num_vsprings;
456 }
457
458 Exit:
459
460#ifdef AH_DEBUG_OPTIM
461 AH_Dump_Springs( optimizer );
462#endif
463
464 return error;
465 }
466
467
468 /*************************************************************************/
469 /*************************************************************************/
470 /*************************************************************************/
471 /**** ****/
472 /**** OPTIMIZE THROUGH MY STRANGE SIMULATED ANNEALING ALGO ;-) ****/
473 /**** ****/
474 /*************************************************************************/
475 /*************************************************************************/
476 /*************************************************************************/
477
478#ifndef AH_BRUTE_FORCE
479
480 /* compute all spring tensions */
481 static
482 void optim_compute_tensions( AH_Optimizer* optimizer )
483 {
484 AH_Spring* spring = optimizer->springs;
485 AH_Spring* limit = spring + optimizer->num_springs;
486
487
488 for ( ; spring < limit; spring++ )
489 {
490 AH_Stem* stem1 = spring->stem1;
491 AH_Stem* stem2 = spring->stem2;
492 FT_Int status;
493
494 FT_Pos width;
495 FT_Pos tension;
496 FT_Pos sign;
497
498
499 /* compute the tension; it simply is -K*(new_width-old_width) */
500 width = stem2->pos - ( stem1->pos + stem1->width );
501 tension = width - spring->owidth;
502
503 sign = 1;
504 if ( tension < 0 )
505 {
506 sign = -1;
507 tension = -tension;
508 }
509
510 if ( width <= 0 )
511 tension = 32000;
512 else
513 tension = ( tension << 10 ) / width;
514
515 tension = -sign * FT_MulFix( tension, optimizer->tension_scale );
516 spring->tension = tension;
517
518 /* now, distribute tension among the englobing stems, if they */
519 /* are able to move */
520 status = 0;
521 if ( stem1->pos <= stem1->min_pos )
522 status |= 1;
523 if ( stem2->pos >= stem2->max_pos )
524 status |= 2;
525
526 if ( !status )
527 tension /= 2;
528
529 if ( ( status & 1 ) == 0 )
530 stem1->force -= tension;
531
532 if ( ( status & 2 ) == 0 )
533 stem2->force += tension;
534 }
535 }
536
537
538 /* compute all stem movements -- returns 0 if nothing moved */
539 static
540 int optim_compute_stem_movements( AH_Optimizer* optimizer )
541 {
542 AH_Stem* stems = optimizer->stems;
543 AH_Stem* limit = stems + optimizer->num_stems;
544 AH_Stem* stem = stems;
545 int moved = 0;
546
547
548 /* set initial forces to velocity */
549 for ( stem = stems; stem < limit; stem++ )
550 {
551 stem->force = stem->velocity;
552 stem->velocity /= 2; /* XXX: Heuristics */
553 }
554
555 /* compute the sum of forces applied on each stem */
556 optim_compute_tensions( optimizer );
557
558#ifdef AH_DEBUG_OPTIM
559 AH_Dump_Springs( optimizer );
560 AH_Dump_Stems2( optimizer );
561#endif
562
563 /* now, see whether something can move */
564 for ( stem = stems; stem < limit; stem++ )
565 {
566 if ( stem->force > optimizer->tension_threshold )
567 {
568 /* there is enough tension to move the stem to the right */
569 if ( stem->pos < stem->max_pos )
570 {
571 stem->pos += 64;
572 stem->velocity = stem->force / 2;
573 moved = 1;
574 }
575 else
576 stem->velocity = 0;
577 }
578 else if ( stem->force < optimizer->tension_threshold )
579 {
580 /* there is enough tension to move the stem to the left */
581 if ( stem->pos > stem->min_pos )
582 {
583 stem->pos -= 64;
584 stem->velocity = stem->force / 2;
585 moved = 1;
586 }
587 else
588 stem->velocity = 0;
589 }
590 }
591
592 /* return 0 if nothing moved */
593 return moved;
594 }
595
596#endif /* AH_BRUTE_FORCE */
597
598
599 /* compute current global distortion from springs */
600 static
601 FT_Pos optim_compute_distortion( AH_Optimizer* optimizer )
602 {
603 AH_Spring* spring = optimizer->springs;
604 AH_Spring* limit = spring + optimizer->num_springs;
605 FT_Pos distortion = 0;
606
607
608 for ( ; spring < limit; spring++ )
609 {
610 AH_Stem* stem1 = spring->stem1;
611 AH_Stem* stem2 = spring->stem2;
612 FT_Pos width;
613
614 width = stem2->pos - ( stem1->pos + stem1->width );
615 width -= spring->owidth;
616 if ( width < 0 )
617 width = -width;
618
619 distortion += width;
620 }
621
622 return distortion;
623 }
624
625
626 /* record stems configuration in `best of' history */
627 static
628 void optim_record_configuration( AH_Optimizer* optimizer )
629 {
630 FT_Pos distortion;
631 AH_Configuration* configs = optimizer->configs;
632 AH_Configuration* limit = configs + optimizer->num_configs;
633 AH_Configuration* config;
634
635
636 distortion = optim_compute_distortion( optimizer );
637 LOG(( "config distortion = %.1f ", FLOAT( distortion * 64 ) ));
638
639 /* check that we really need to add this configuration to our */
640 /* sorted history */
641 if ( limit > configs && limit[-1].distortion < distortion )
642 {
643 LOG(( "ejected\n" ));
644 return;
645 }
646
647 /* add new configuration at the end of the table */
648 {
649 int n;
650
651
652 config = limit;
653 if ( optimizer->num_configs < AH_MAX_CONFIGS )
654 optimizer->num_configs++;
655 else
656 config--;
657
658 config->distortion = distortion;
659
660 for ( n = 0; n < optimizer->num_stems; n++ )
661 config->positions[n] = optimizer->stems[n].pos;
662 }
663
664 /* move the current configuration towards the front of the list */
665 /* when necessary -- yes this is slow bubble sort ;-) */
666 while ( config > configs && config[0].distortion < config[-1].distortion )
667 {
668 AH_Configuration temp;
669
670
671 config--;
672 temp = config[0];
673 config[0] = config[1];
674 config[1] = temp;
675 }
676 LOG(( "recorded!\n" ));
677 }
678
679
680#ifdef AH_BRUTE_FORCE
681
682 /* optimize outline in a single direction */
683 static
684 void optim_compute( AH_Optimizer* optimizer )
685 {
686 int n;
687 FT_Bool moved;
688
689 AH_Stem* stem = optimizer->stems;
690 AH_Stem* limit = stem + optimizer->num_stems;
691
692
693 /* empty, exit */
694 if ( stem >= limit )
695 return;
696
697 optimizer->num_configs = 0;
698
699 stem = optimizer->stems;
700 for ( ; stem < limit; stem++ )
701 stem->pos = stem->min_pos;
702
703 do
704 {
705 /* record current configuration */
706 optim_record_configuration( optimizer );
707
708 /* now change configuration */
709 moved = 0;
710 for ( stem = optimizer->stems; stem < limit; stem++ )
711 {
712 if ( stem->pos < stem->max_pos )
713 {
714 stem->pos += 64;
715 moved = 1;
716 break;
717 }
718
719 stem->pos = stem->min_pos;
720 }
721 } while ( moved );
722
723 /* now, set the best stem positions */
724 for ( n = 0; n < optimizer->num_stems; n++ )
725 {
726 AH_Stem* stem = optimizer->stems + n;
727 FT_Pos pos = optimizer->configs[0].positions[n];
728
729
730 stem->edge1->pos = pos;
731 stem->edge2->pos = pos + stem->width;
732
733 stem->edge1->flags |= ah_edge_done;
734 stem->edge2->flags |= ah_edge_done;
735 }
736 }
737
738#else /* AH_BRUTE_FORCE */
739
740 /* optimize outline in a single direction */
741 static
742 void optim_compute( AH_Optimizer* optimizer )
743 {
744 int n, counter, counter2;
745
746
747 optimizer->num_configs = 0;
748 optimizer->tension_scale = 0x80000L;
749 optimizer->tension_threshold = 64;
750
751 /* record initial configuration threshold */
752 optim_record_configuration( optimizer );
753
754 counter = 0;
755 for ( counter2 = optimizer->num_stems*8; counter2 >= 0; counter2-- )
756 {
757 if ( counter == 0 )
758 counter = 2 * optimizer->num_stems;
759
760 if ( !optim_compute_stem_movements( optimizer ) )
761 break;
762
763 optim_record_configuration( optimizer );
764
765 counter--;
766 if ( counter == 0 )
767 optimizer->tension_scale /= 2;
768 }
769
770 /* now, set the best stem positions */
771 for ( n = 0; n < optimizer->num_stems; n++ )
772 {
773 AH_Stem* stem = optimizer->stems + n;
774 FT_Pos pos = optimizer->configs[0].positions[n];
775
776
777 stem->edge1->pos = pos;
778 stem->edge2->pos = pos + stem->width;
779
780 stem->edge1->flags |= ah_edge_done;
781 stem->edge2->flags |= ah_edge_done;
782 }
783 }
784
785#endif /* AH_BRUTE_FORCE */
786
787
788 /*************************************************************************/
789 /*************************************************************************/
790 /*************************************************************************/
791 /**** ****/
792 /**** HIGH-LEVEL OPTIMIZER API ****/
793 /**** ****/
794 /*************************************************************************/
795 /*************************************************************************/
796 /*************************************************************************/
797
798
799 /* releases the optimization data */
800 void AH_Optimizer_Done( AH_Optimizer* optimizer )
801 {
802 if ( optimizer )
803 {
804 FT_Memory memory = optimizer->memory;
805
806
807 FREE( optimizer->horz_stems );
808 FREE( optimizer->vert_stems );
809 FREE( optimizer->horz_springs );
810 FREE( optimizer->vert_springs );
811 FREE( optimizer->positions );
812 }
813 }
814
815
816 /* loads the outline into the optimizer */
817 int AH_Optimizer_Init( AH_Optimizer* optimizer,
818 AH_Outline* outline,
819 FT_Memory memory )
820 {
821 FT_Error error;
822
823
824 MEM_Set( optimizer, 0, sizeof ( *optimizer ) );
825 optimizer->outline = outline;
826 optimizer->memory = memory;
827
828 LOG(( "initializing new optimizer\n" ));
829 /* compute stems and springs */
830 error = optim_compute_stems ( optimizer ) ||
831 optim_compute_springs( optimizer );
832 if ( error )
833 goto Fail;
834
835 /* allocate stem positions history and configurations */
836 {
837 int n, max_stems;
838
839
840 max_stems = optimizer->num_hstems;
841 if ( max_stems < optimizer->num_vstems )
842 max_stems = optimizer->num_vstems;
843
844 if ( ALLOC_ARRAY( optimizer->positions,
845 max_stems * AH_MAX_CONFIGS, FT_Pos ) )
846 goto Fail;
847
848 optimizer->num_configs = 0;
849 for ( n = 0; n < AH_MAX_CONFIGS; n++ )
850 optimizer->configs[n].positions = optimizer->positions +
851 n * max_stems;
852 }
853
854 return error;
855
856 Fail:
857 AH_Optimizer_Done( optimizer );
858 return error;
859 }
860
861
862 /* compute optimal outline */
863 void AH_Optimizer_Compute( AH_Optimizer* optimizer )
864 {
865 optimizer->num_stems = optimizer->num_hstems;
866 optimizer->stems = optimizer->horz_stems;
867 optimizer->num_springs = optimizer->num_hsprings;
868 optimizer->springs = optimizer->horz_springs;
869
870 if ( optimizer->num_springs > 0 )
871 {
872 LOG(( "horizontal optimization ------------------------\n" ));
873 optim_compute( optimizer );
874 }
875
876 optimizer->num_stems = optimizer->num_vstems;
877 optimizer->stems = optimizer->vert_stems;
878 optimizer->num_springs = optimizer->num_vsprings;
879 optimizer->springs = optimizer->vert_springs;
880
881 if ( optimizer->num_springs )
882 {
883 LOG(( "vertical optimization --------------------------\n" ));
884 optim_compute( optimizer );
885 }
886 }
887
888
889/* END */
wxWidgets (Impactor)