00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
#include <volume_io/internal_volume_io.h>
00016
#include <bicpl/objects.h>
00017
#include <bicpl/geom.h>
00018
00019
#ifndef lint
00020
static char rcsid[] =
"$Header: /software/source//libraries/bicpl/Objects/objects.c,v 1.23 2000/02/06 15:30:44 stever Exp $";
00021
#endif
00022
00023
private void advance_object_traverse(
00024
object_traverse_struct *object_traverse );
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039 public object_struct *
create_object(
00040 Object_types object_type )
00041 {
00042
object_struct *object;
00043
00044 ALLOC( object, 1 );
00045
00046 object->
object_type = object_type;
00047 object->
visibility =
TRUE;
00048
00049
return( object );
00050 }
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 public Object_types get_object_type(
00066
object_struct *object )
00067 {
00068
return( object->
object_type );
00069 }
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084 public BOOLEAN
get_object_visibility(
00085
object_struct *object )
00086 {
00087
return( object->
visibility );
00088 }
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104 public void set_object_visibility(
00105
object_struct *object,
00106 BOOLEAN visibility )
00107 {
00108 object->
visibility = visibility;
00109 }
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124 public lines_struct *
get_lines_ptr(
00125
object_struct *object )
00126 {
00127
if( object->
object_type !=
LINES )
00128 {
00129 handle_internal_error(
"get_lines_ptr" );
00130
return( (
lines_struct *) NULL );
00131 }
00132
else
00133
return( &object->
specific.lines );
00134 }
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149 public marker_struct *
get_marker_ptr(
00150
object_struct *object )
00151 {
00152
if( object->
object_type !=
MARKER )
00153 {
00154 handle_internal_error(
"get_marker_ptr" );
00155
return( (
marker_struct *) NULL );
00156 }
00157
else
00158
return( &object->
specific.marker );
00159 }
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174 public model_struct *
get_model_ptr(
00175
object_struct *object )
00176 {
00177
if( object->
object_type !=
MODEL )
00178 {
00179 handle_internal_error(
"get_model_ptr" );
00180
return( (
model_struct *) NULL );
00181 }
00182
else
00183
return( &object->
specific.model );
00184 }
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199 public pixels_struct *
get_pixels_ptr(
00200
object_struct *object )
00201 {
00202
if( object->
object_type !=
PIXELS )
00203 {
00204 handle_internal_error(
"get_pixels_ptr" );
00205
return( (
pixels_struct *) NULL );
00206 }
00207
else
00208
return( &object->
specific.pixels );
00209 }
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224 public polygons_struct *
get_polygons_ptr(
00225
object_struct *object )
00226 {
00227
if( object->
object_type !=
POLYGONS )
00228 {
00229 handle_internal_error(
"get_polygons_ptr" );
00230
return( (
polygons_struct *) NULL );
00231 }
00232
else
00233
return( &object->
specific.polygons );
00234 }
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249 public quadmesh_struct *
get_quadmesh_ptr(
00250
object_struct *object )
00251 {
00252
if( object->
object_type !=
QUADMESH )
00253 {
00254 handle_internal_error(
"get_quadmesh_ptr" );
00255
return( (
quadmesh_struct *) NULL );
00256 }
00257
else
00258
return( &object->
specific.quadmesh );
00259 }
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274 public text_struct *
get_text_ptr(
00275
object_struct *object )
00276 {
00277
if( object->
object_type !=
TEXT )
00278 {
00279 handle_internal_error(
"get_text_ptr" );
00280
return( (
text_struct *) NULL );
00281 }
00282
else
00283
return( &object->
specific.text );
00284 }
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300 private int get_lines_points(
00301
object_struct *object,
00302 Point *points[] )
00303 {
00304 *points =
get_lines_ptr(object)->
points;
00305
00306
return(
get_lines_ptr(object)->
n_points );
00307 }
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323 private int get_marker_points(
00324
object_struct *object,
00325 Point *points[] )
00326 {
00327 *points = &
get_marker_ptr(object)->
position;
00328
00329
return( 1 );
00330 }
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340
00341
00342
00343
00344
00345
00346
00347
00348 private int get_object_zero_points(
00349
object_struct *object,
00350 Point *points[] )
00351 {
00352
return( 0 );
00353 }
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367
00368
00369 private int get_polygons_points(
00370
object_struct *object,
00371 Point *points[] )
00372 {
00373 *points =
get_polygons_ptr(object)->
points;
00374
00375
return(
get_polygons_ptr(object)->
n_points );
00376 }
00377
00378
00379
00380
00381
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392 private int get_quadmesh_points(
00393
object_struct *object,
00394 Point *points[] )
00395 {
00396 *points =
get_quadmesh_ptr(object)->
points;
00397
00398
return(
get_quadmesh_ptr(object)->
m *
get_quadmesh_ptr(object)->
n );
00399 }
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415 private int get_text_points(
00416
object_struct *object,
00417 Point *points[] )
00418 {
00419 *points = &
get_text_ptr(object)->
origin;
00420
00421
return( 1 );
00422 }
00423
00424
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440 private int get_object_zero_normals(
00441
object_struct *object,
00442 Vector *normals[] )
00443 {
00444 *normals = NULL;
00445
return( 0 );
00446 }
00447
00448
00449
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461
00462 private int get_polygons_normals(
00463
object_struct *object,
00464 Vector *normals[] )
00465 {
00466 *normals =
get_polygons_ptr(object)->
normals;
00467
00468
return(
get_polygons_ptr(object)->
n_points );
00469 }
00470
00471
00472
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483
00484
00485 private int get_quadmesh_normals(
00486
object_struct *object,
00487 Vector *normals[] )
00488 {
00489 *normals =
get_quadmesh_ptr(object)->
normals;
00490
00491
return(
get_quadmesh_ptr(object)->
m *
get_quadmesh_ptr(object)->
n );
00492 }
00493
00494
00495
00496
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508 private Colour_flags *
get_lines_colours(
00509
object_struct *object,
00510 Colour *colours[] )
00511 {
00512 *colours =
get_lines_ptr(object)->
colours;
00513
00514
return( &
get_lines_ptr(object)->
colour_flag );
00515 }
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526
00527
00528
00529
00530
00531 private Colour_flags *
get_marker_colours(
00532
object_struct *object,
00533 Colour *colours[] )
00534 {
00535 *colours = &
get_marker_ptr(object)->
colour;
00536
00537
return( (
Colour_flags *) 0 );
00538 }
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550
00551
00552
00553
00554
00555
00556 private Colour_flags *
get_object_zero_colours(
00557
object_struct *object,
00558 Colour *colours[] )
00559 {
00560 *colours = (Colour *) NULL;
00561
00562
return( (
Colour_flags *) 0 );
00563 }
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579 private Colour_flags *
get_polygons_colours(
00580
object_struct *object,
00581 Colour *colours[] )
00582 {
00583 *colours =
get_polygons_ptr(object)->
colours;
00584
00585
return( &
get_polygons_ptr(object)->
colour_flag );
00586 }
00587
00588
00589
00590
00591
00592
00593
00594
00595
00596
00597
00598
00599
00600
00601
00602 private Colour_flags *
get_quadmesh_colours(
00603
object_struct *object,
00604 Colour *colours[] )
00605 {
00606 *colours =
get_quadmesh_ptr(object)->
colours;
00607
00608
return( &
get_quadmesh_ptr(object)->
colour_flag );
00609 }
00610
00611
00612
00613
00614
00615
00616
00617
00618
00619
00620
00621
00622
00623
00624
00625 private Colour_flags *
get_text_colours(
00626
object_struct *object,
00627 Colour *colours[] )
00628 {
00629 *colours = &
get_text_ptr(object)->
colour;
00630
00631
return( (
Colour_flags *) 0 );
00632 }
00633
00634
00635
00636
00637
00638
00639
00640
00641
00642
00643
00644
00645
00646
00647
00648 private void set_lines_colours(
00649
object_struct *object,
00650 Colour colours[] )
00651 {
00652
get_lines_ptr(object)->
colours = colours;
00653 }
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672 private void set_object_no_colours(
00673
object_struct *object,
00674 Colour colours[] )
00675 {
00676 }
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692 private void set_polygons_colours(
00693
object_struct *object,
00694 Colour colours[] )
00695 {
00696
get_polygons_ptr(object)->
colours = colours;
00697 }
00698
00699
00700
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713 private void set_quadmesh_colours(
00714
object_struct *object,
00715 Colour colours[] )
00716 {
00717
get_quadmesh_ptr(object)->
colours = colours;
00718 }
00719
00720
00721
00722
00723
00724
00725
00726
00727
00728
00729
00730
00731
00732
00733
00734
00735 private Surfprop *
get_object_no_surfprop(
00736
object_struct *object )
00737 {
00738
return( (Surfprop *) NULL );
00739 }
00740
00741
00742
00743
00744
00745
00746
00747
00748
00749
00750
00751
00752
00753
00754 private Surfprop *
get_polygons_surfprop(
00755
object_struct *object )
00756 {
00757
return( &
get_polygons_ptr(object)->
surfprop );
00758 }
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773 private Surfprop *
get_quadmesh_surfprop(
00774
object_struct *object )
00775 {
00776
return( &
get_quadmesh_ptr(object)->
surfprop );
00777 }
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792 private STRING
get_lines_name(
00793
object_struct *object )
00794 {
00795
char buffer[EXTREMELY_LARGE_STRING_SIZE];
00796
00797 (
void) sprintf( buffer,
"Lines (%d:%d)",
00798
get_lines_ptr(object)->n_items,
00799
get_lines_ptr(object)->n_points );
00800
00801
return( create_string( buffer ) );
00802 }
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817 private STRING
get_marker_name(
00818
object_struct *object )
00819 {
00820 STRING label;
00821
char buffer[EXTREMELY_LARGE_STRING_SIZE];
00822
00823
if( string_length(
get_marker_ptr(object)->label) == 0 )
00824 label =
"Marker";
00825
else
00826 label =
get_marker_ptr(object)->
label;
00827
00828 (
void) sprintf( buffer,
"%s:%d:%d: (%g %g %g)",
00829 label,
00830
get_marker_ptr(object)->patient_id,
00831
get_marker_ptr(object)->structure_id,
00832 Point_x(
get_marker_ptr(object)->position),
00833 Point_y(
get_marker_ptr(object)->position),
00834 Point_z(
get_marker_ptr(object)->position) );
00835
00836
return( create_string( buffer ) );
00837 }
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852 private STRING
get_model_name(
00853
object_struct *object )
00854 {
00855
char buffer[EXTREMELY_LARGE_STRING_SIZE];
00856
00857 (
void) sprintf( buffer,
"Model (%s) ->",
get_model_ptr(object)->filename );
00858
00859
return( create_string( buffer ) );
00860 }
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875 private STRING
get_pixels_name(
00876
object_struct *object )
00877 {
00878
char buffer[EXTREMELY_LARGE_STRING_SIZE];
00879
00880 (
void) sprintf( buffer,
"Pixels (%d by %d)",
00881
get_pixels_ptr(object)->x_size,
00882
get_pixels_ptr(object)->y_size );
00883
00884
return( create_string( buffer ) );
00885 }
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900 private STRING
get_polygons_name(
00901
object_struct *object )
00902 {
00903
char buffer[EXTREMELY_LARGE_STRING_SIZE];
00904
00905 (
void) sprintf( buffer,
"Polygons (%d:%d)",
00906
get_polygons_ptr(object)->n_items,
00907
get_polygons_ptr(object)->n_points );
00908
00909
return( create_string( buffer ) );
00910 }
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925 private STRING
get_quadmesh_name(
00926
object_struct *object )
00927 {
00928
char buffer[EXTREMELY_LARGE_STRING_SIZE];
00929
00930 (
void) sprintf( buffer,
"Quadmesh [%d][%d]",
00931
get_quadmesh_ptr(object)->m,
get_quadmesh_ptr(object)->n );
00932
00933
return( create_string( buffer ) );
00934 }
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949 private STRING
get_text_name(
00950
object_struct *object )
00951 {
00952
char buffer[EXTREMELY_LARGE_STRING_SIZE];
00953
00954 (
void) sprintf( buffer,
"Text (%s)",
get_text_ptr(object)->string );
00955
00956
return( create_string( buffer ) );
00957 }
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972 private void delete_lines_object(
00973
object_struct *object )
00974 {
00975
delete_lines(
get_lines_ptr(object) );
00976 }
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993 private void delete_marker_object(
00994
object_struct *object )
00995 {
00996
delete_marker(
get_marker_ptr(object) );
00997 }
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012 private void delete_model_object(
01013
object_struct *object )
01014 {
01015
delete_model(
get_model_ptr(object) );
01016 }
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031 private void delete_pixels_object(
01032
object_struct *object )
01033 {
01034
delete_pixels(
get_pixels_ptr(object) );
01035 }
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050 private void delete_polygons_object(
01051
object_struct *object )
01052 {
01053
delete_polygons(
get_polygons_ptr(object) );
01054 }
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071 private void delete_quadmesh_object(
01072
object_struct *object )
01073 {
01074
delete_quadmesh(
get_quadmesh_ptr(object) );
01075 }
01076
01077
01078
01079
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092 private void delete_text_object(
01093
object_struct *object )
01094 {
01095
delete_text(
get_text_ptr(object) );
01096 }
01097
01098
01099
01100 typedef struct
01101
{
01102 int (*get_points_function)(
object_struct *, Point *[] );
01103 int (*get_normals_function)(
object_struct *, Vector *[] );
01104
Colour_flags *(*get_colours_function)(
object_struct *, Colour *[] );
01105 void (*set_colours_function)(
object_struct *, Colour [] );
01106 Surfprop *(*get_surfprop_function)(
object_struct * );
01107 STRING (*get_name_function)(
object_struct * );
01108 void (*delete_function)(
object_struct * );
01109 }
01110
object_functions_list;
01111
01112
static object_functions_list object_functions[
N_OBJECT_TYPES] =
01113 {
01114 {
01115
get_lines_points,
01116
get_object_zero_normals,
01117
get_lines_colours,
01118
set_lines_colours,
01119
get_object_no_surfprop,
01120
get_lines_name,
01121
delete_lines_object
01122 },
01123 {
01124
get_marker_points,
01125
get_object_zero_normals,
01126
get_marker_colours,
01127
set_object_no_colours,
01128
get_object_no_surfprop,
01129
get_marker_name,
01130
delete_marker_object
01131 },
01132 {
01133
get_object_zero_points,
01134
get_object_zero_normals,
01135
get_object_zero_colours,
01136
set_object_no_colours,
01137
get_object_no_surfprop,
01138
get_model_name,
01139
delete_model_object
01140 },
01141 {
01142
get_object_zero_points,
01143
get_object_zero_normals,
01144
get_object_zero_colours,
01145
set_object_no_colours,
01146
get_object_no_surfprop,
01147
get_pixels_name,
01148
delete_pixels_object
01149 },
01150 {
01151
get_polygons_points,
01152
get_polygons_normals,
01153
get_polygons_colours,
01154
set_polygons_colours,
01155
get_polygons_surfprop,
01156
get_polygons_name,
01157
delete_polygons_object
01158 },
01159 {
01160
get_quadmesh_points,
01161
get_quadmesh_normals,
01162
get_quadmesh_colours,
01163
set_quadmesh_colours,
01164
get_quadmesh_surfprop,
01165
get_quadmesh_name,
01166
delete_quadmesh_object
01167 },
01168 {
01169
get_text_points,
01170
get_object_zero_normals,
01171
get_text_colours,
01172
set_object_no_colours,
01173
get_object_no_surfprop,
01174
get_text_name,
01175
delete_text_object
01176 }
01177 };
01178
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192 public void delete_object(
01193
object_struct *object )
01194 {
01195 object_functions[object->
object_type].
delete_function( object );
01196 FREE( object );
01197 }
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212 public int get_object_points(
01213
object_struct *object,
01214 Point *points[] )
01215 {
01216
return( object_functions[object->
object_type].
get_points_function
01217 ( object, points ) );
01218 }
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233 public int get_object_normals(
01234
object_struct *object,
01235 Vector *normals[] )
01236 {
01237
return( object_functions[object->
object_type].
get_normals_function
01238 ( object, normals ) );
01239 }
01240
01241
01242
01243
01244
01245
01246
01247
01248
01249
01250
01251
01252
01253
01254 public Colour_flags *
get_object_colours(
01255
object_struct *object,
01256 Colour *colours[] )
01257 {
01258
return( object_functions[object->
object_type].
get_colours_function
01259 ( object, colours ) );
01260 }
01261
01262
01263
01264
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276 public void set_object_colours(
01277
object_struct *object,
01278 Colour colours[] )
01279 {
01280 object_functions[object->
object_type].
set_colours_function(object,colours);
01281 }
01282
01283
01284
01285
01286
01287
01288
01289
01290
01291
01292
01293
01294
01295
01296 public Surfprop *
get_object_surfprop(
01297
object_struct *object )
01298 {
01299
return( object_functions[object->
object_type].
get_surfprop_function
01300 ( object ) );
01301 }
01302
01303
01304
01305
01306
01307
01308
01309
01310
01311
01312
01313
01314
01315
01316 public STRING
get_object_name(
01317
object_struct *object )
01318 {
01319
return( object_functions[object->
object_type].
get_name_function( object ) );
01320 }
01321
01322 private void pop_object_stack(
01323
object_traverse_struct *object_traverse )
01324 {
01325
if( object_traverse->
top_of_stack > 0 )
01326 --object_traverse->
top_of_stack;
01327
else
01328 handle_internal_error(
"pop_object_stack" );
01329 }
01330
01331 private void push_object_stack(
01332
object_traverse_struct *object_traverse,
01333
object_stack_struct *entry )
01334 {
01335
if( object_traverse->
top_of_stack+1 >= object_traverse->
n_stack_alloced )
01336 {
01337 SET_ARRAY_SIZE( object_traverse->
alloced_stack,
01338 object_traverse->
top_of_stack,
01339 object_traverse->
top_of_stack+1,
01340 DEFAULT_CHUNK_SIZE );
01341
01342 object_traverse->
stack = object_traverse->
alloced_stack;
01343 }
01344
01345 object_traverse->
stack[object_traverse->
top_of_stack] = *entry;
01346 ++object_traverse->
top_of_stack;
01347 }
01348
01349
01350
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360
01361
01362
01363
01364
01365 public void initialize_object_traverse(
01366
object_traverse_struct *object_traverse,
01367 BOOLEAN visible_ones_only,
01368
int n_objects,
01369
object_struct *object_list[] )
01370 {
01371
object_stack_struct push_entry;
01372
01373 object_traverse->
visible_ones_only = visible_ones_only;
01374 object_traverse->
n_stack_alloced =
MAX_OBJECT_TRAVERSE;
01375 object_traverse->
top_of_stack = 0;
01376 object_traverse->
stack = object_traverse->
static_stack;
01377
01378
if( n_objects > 0 )
01379 {
01380 push_entry.
index = 0;
01381 push_entry.
n_objects = n_objects;
01382 push_entry.
object_list = object_list;
01383
01384
while( push_entry.
index < n_objects &&
01385 visible_ones_only &&
01386 !
get_object_visibility( object_list[push_entry.
index] ) )
01387 ++push_entry.
index;
01388
01389
if( push_entry.
index < n_objects )
01390
push_object_stack( object_traverse, &push_entry );
01391 }
01392 }
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407 public BOOLEAN
get_next_object_traverse(
01408
object_traverse_struct *object_traverse,
01409
object_struct **object )
01410 {
01411 BOOLEAN object_found;
01412
object_stack_struct *top_entry;
01413
01414
if( object_traverse->
top_of_stack > 0 )
01415 {
01416 top_entry = &object_traverse->
stack[object_traverse->
top_of_stack-1];
01417 *object = top_entry->
object_list[top_entry->
index];
01418
01419
advance_object_traverse( object_traverse );
01420 object_found =
TRUE;
01421 }
01422
else
01423 {
01424
terminate_object_traverse( object_traverse );
01425 object_found =
FALSE;
01426 }
01427
01428
return( object_found );
01429 }
01430
01431
01432
01433
01434
01435
01436
01437
01438
01439
01440
01441
01442
01443
01444 private void advance_object_traverse(
01445
object_traverse_struct *object_traverse )
01446 {
01447
object_stack_struct *top_entry, push_entry;
01448
object_struct *object;
01449
model_struct *model;
01450
01451 top_entry = &object_traverse->
stack[object_traverse->
top_of_stack-1];
01452 object = top_entry->
object_list[top_entry->
index];
01453 ++top_entry->
index;
01454
01455
while( top_entry->
index < top_entry->
n_objects &&
01456 object_traverse->
visible_ones_only &&
01457 !
get_object_visibility( top_entry->
object_list[top_entry->
index]) )
01458 {
01459 ++top_entry->
index;
01460 }
01461
01462
if( object->
object_type ==
MODEL )
01463 {
01464 model =
get_model_ptr( object );
01465 push_entry.
index = 0;
01466 push_entry.
n_objects = model->
n_objects;
01467 push_entry.
object_list = model->
objects;
01468
01469
while( push_entry.
index < push_entry.
n_objects &&
01470 object_traverse->
visible_ones_only &&
01471 !
get_object_visibility(push_entry.
object_list[push_entry.
index]))
01472 ++push_entry.
index;
01473
01474
if( push_entry.
index < push_entry.
n_objects )
01475
push_object_stack( object_traverse, &push_entry );
01476 }
01477
01478
while( object_traverse->
top_of_stack > 0 &&
01479 object_traverse->
stack[object_traverse->
top_of_stack-1].
index >=
01480 object_traverse->
stack[object_traverse->
top_of_stack-1].
n_objects )
01481 {
01482
pop_object_stack( object_traverse );
01483 }
01484 }
01485
01486
01487
01488
01489
01490
01491
01492
01493
01494
01495
01496
01497
01498
01499 public void terminate_object_traverse(
01500
object_traverse_struct *object_traverse )
01501 {
01502
if( object_traverse->
n_stack_alloced >
MAX_OBJECT_TRAVERSE )
01503 FREE( object_traverse->
alloced_stack );
01504 }
01505
01506
01507
01508
01509
01510
01511
01512
01513
01514
01515
01516
01517
01518
01519
01520
01521 public BOOLEAN
get_range_of_object(
01522
object_struct *object,
01523 BOOLEAN visible_ones_only,
01524 Point *min_corner,
01525 Point *max_corner )
01526 {
01527 BOOLEAN found_flag;
01528 Point min_obj, max_obj, *points;
01529
int n_points;
01530
object_struct *current_object;
01531
object_traverse_struct object_traverse;
01532
01533 found_flag =
FALSE;
01534
01535
initialize_object_traverse( &object_traverse, visible_ones_only, 1,&object);
01536
01537
while(
get_next_object_traverse( &object_traverse, ¤t_object ) )
01538 {
01539 n_points =
get_object_points( current_object, &points );
01540
01541
if( n_points > 0 )
01542 {
01543
get_range_points( n_points, points, &min_obj, &max_obj );
01544
01545
if( !found_flag )
01546 {
01547 found_flag =
TRUE;
01548 *min_corner = min_obj;
01549 *max_corner = max_obj;
01550 }
01551
else
01552 {
01553
expand_min_and_max_points( min_corner, max_corner,
01554 &min_obj, &max_obj );
01555 }
01556 }
01557 }
01558
01559
return( found_flag );
01560 }
01561
01562
01563
01564
01565
01566
01567
01568
01569
01570
01571
01572
01573
01574
01575 public void reverse_object_normals(
01576
object_struct *object )
01577 {
01578
int n_normals;
01579 Vector *normals;
01580
object_struct *current_object;
01581
object_traverse_struct object_traverse;
01582
01583
initialize_object_traverse( &object_traverse,
FALSE, 1, &object );
01584
01585
while(
get_next_object_traverse( &object_traverse, ¤t_object ) )
01586 {
01587 n_normals =
get_object_normals( current_object, &normals );
01588
reverse_vectors( n_normals, normals );
01589 }
01590 }
01591
01592
01593
01594
01595
01596
01597
01598
01599
01600
01601
01602
01603
01604
01605 public BOOLEAN
get_object_colour(
01606
object_struct *object,
01607 Colour *colour )
01608 {
01609 BOOLEAN has_single_colour;
01610
Colour_flags *colour_flag;
01611 Colour *colours;
01612
01613 colour_flag =
get_object_colours( object, &colours );
01614
01615
if( (colour_flag == (
Colour_flags *) NULL ||
01616 *colour_flag ==
ONE_COLOUR) && colours != (Colour *) NULL )
01617 {
01618 has_single_colour =
TRUE;
01619 *colour = colours[0];
01620 }
01621
else
01622 {
01623 has_single_colour =
FALSE;
01624 }
01625
01626
return( has_single_colour );
01627 }
01628
01629
01630
01631
01632
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643 public void set_object_colour(
01644
object_struct *object,
01645 Colour col )
01646 {
01647
Colour_flags *colour_flag;
01648 Colour *colours;
01649
01650 colour_flag =
get_object_colours( object, &colours );
01651
01652
if( colour_flag != (
Colour_flags *) NULL && *colour_flag !=
ONE_COLOUR )
01653 {
01654 *colour_flag =
ONE_COLOUR;
01655
01656
if( colours != (Colour *) NULL )
01657 FREE( colours );
01658
01659 ALLOC( colours, 1 );
01660
set_object_colours( object, colours );
01661 }
01662
01663
if( colours != (Colour *) NULL )
01664 colours[0] = col;
01665 }
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
01681 public void set_object_surfprop(
01682
object_struct *object,
01683 Surfprop *spr )
01684 {
01685 Surfprop *object_spr;
01686
01687 object_spr =
get_object_surfprop( object );
01688
01689
if( object_spr != (Surfprop *) NULL )
01690 *object_spr = *spr;
01691 }
01692
01693
01694
01695
01696
01697
01698
01699
01700
01701
01702
01703
01704
01705
01706
01707
01708
01709 public void free_colours(
01710 Colour_flags colour_flag,
01711 Colour colours[],
01712
int n_points,
01713
int n_items )
01714 {
01715 BOOLEAN should_free;
01716
01717 should_free =
FALSE;
01718
01719
switch( colour_flag )
01720 {
01721
case ONE_COLOUR:
01722 should_free =
TRUE;
01723
break;
01724
01725
case PER_ITEM_COLOURS:
01726 should_free = (n_items > 0);
01727
break;
01728
01729
case PER_VERTEX_COLOURS:
01730 should_free = (n_points > 0);
01731
break;
01732 }
01733
01734
if( should_free )
01735 FREE( colours );
01736 }
01737
01738
01739
01740
01741
01742
01743
01744
01745
01746
01747
01748
01749
01750
01751
01752
01753
01754
01755
01756
01757
01758 public BOOLEAN
objects_are_same_topology(
01759
int n_points1,
01760
int n_items1,
01761
int *end_indices1,
01762
int *indices1,
01763
int n_points2,
01764
int n_items2,
01765
int *end_indices2,
01766
int *indices2 )
01767 {
01768
int p;
01769
01770
if( n_points1 != n_points2 || n_items1 != n_items2 )
01771
return(
FALSE );
01772
01773 for_less( p, 0, n_items1 )
01774
if( end_indices1[p] != end_indices2[p] )
01775
return(
FALSE );
01776
01777 for_less( p, 0, end_indices1[n_items1-1] )
01778
if( indices1[p] != indices2[p] )
01779
return(
FALSE );
01780
01781
return(
TRUE );
01782 }
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799 public int get_n_colours(
01800 Colour_flags colour_flag,
01801
int n_points,
01802
int n_items )
01803 {
01804
int n_colours;
01805
01806
switch( colour_flag )
01807 {
01808
case ONE_COLOUR:
01809 n_colours = 1;
01810
break;
01811
01812
case PER_ITEM_COLOURS:
01813 n_colours = n_items;
01814
break;
01815
01816
case PER_VERTEX_COLOURS:
01817 n_colours = n_points;
01818
break;
01819
01820
default:
01821 print_error(
"invalid colour flag\n" );
01822 n_colours = 0;
01823
break;
01824 }
01825
01826
return( n_colours );
01827 }