SDDS ToolKit Programs and Libraries for C and Python
•All Classes Files Functions Variables Macros Pages
Functions
sddsimageprofiles.c File Reference

Detailed Description

Analyze images stored as horizontal lines (one per column) based on the ideas of B-X Yang.

This program processes image data stored in SDDS (Self Describing Data Set) format, allowing for various profile analyses such as center line, integrated, averaged, or peak profiles. It can handle background subtraction and define specific areas of interest within the image.

Usage

sddsimageprofiles [<inputfile>] [<outputfile>]
[-pipe=[input][,output]]
-columnPrefix=<prefix>
[-profileType={x|y}]
[-method={centerLine|integrated|averaged|peak}]
[-background=<filename>]
[-areaOfInterest=<rowStart>,<rowEnd>,<columnStart>,<columnEnd>]

Options

Required Description
-columnPrefix Set the column prefix.
Option Description
-pipe Specify input and/or output via pipe.
-profileType Choose profile type: x or y.
-method Select the method for profile analysis: centerLine, integrated, averaged, peak.
-background Specify a background image file.
-areaOfInterest Define the area of interest within the image.
Copyright
  • (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
  • (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.
License
This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.
Authors
  • R. Soliday
  • Xuesong Jiao

Definition in file sddsimageprofiles.c.

#include "mdb.h"
#include "SDDS.h"
#include "scan.h"

Go to the source code of this file.

Functions

int xImageProfile (IMAGE_DATA *data, int32_t *type, int64_t rows, SDDS_DATASET *SDDS_dataset, long method, int64_t x1, int64_t x2, long y1, long y2, long *colIndex, double *colIndex2)
 
int yImageProfile (IMAGE_DATA *data, int32_t *type, int64_t rows, SDDS_DATASET *SDDS_dataset, long method, int64_t x1, int64_t x2, long y1, long y2, long *colIndex, double *colIndex2)
 
int64_t xPeakLine (IMAGE_DATA *data, int32_t *type, long *colIndex, int64_t x1, int64_t x2, long y1, long y2)
 
long yPeakLine (IMAGE_DATA *data, int32_t *type, long *colIndex, int64_t x1, int64_t x2, long y1, long y2)
 
int64_t xCenterLine (IMAGE_DATA *data, int32_t *type, long *colIndex, int64_t x1, int64_t x2, long y1, long y2)
 
long yCenterLine (IMAGE_DATA *data, int32_t *type, long *colIndex, int64_t x1, int64_t x2, long y1, long y2)
 
int64_t GetData (SDDS_DATASET *SDDS_orig, char *input, IMAGE_DATA **data, int32_t **type, long **colIndex, double **colIndex2, char *colPrefix, long *validColumns)
 
int main (int argc, char **argv)
 

Function Documentation

◆ GetData()

int64_t GetData ( SDDS_DATASET * SDDS_orig,
char * input,
IMAGE_DATA ** data,
int32_t ** type,
long ** colIndex,
double ** colIndex2,
char * colPrefix,
long * validColumns )

Definition at line 1079 of file sddsimageprofiles.c.

1080 {
1081 int64_t rows;
1082 long i, j, temp;
1083 double temp2;
1084 int32_t orig_column_names;
1085 char **orig_column_name;
1086
1087 /* Open image file */
1088 if (!SDDS_InitializeInput(SDDS_orig, input)) {
1089 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1090 exit(EXIT_FAILURE);
1091 }
1092
1093 /* Read column names */
1094 if (!(orig_column_name = SDDS_GetColumnNames(SDDS_orig, &orig_column_names))) {
1095 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1096 exit(EXIT_FAILURE);
1097 }
1098
1099 /* Allocate memory for image file data */
1100 *data = malloc(sizeof(IMAGE_DATA) * orig_column_names);
1101 *type = malloc(sizeof(int32_t) * orig_column_names);
1102
1103 /* Read page */
1104 if (SDDS_ReadPage(SDDS_orig) != 1) {
1105 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1106 exit(EXIT_FAILURE);
1107 }
1108
1109 /* Get number of rows */
1110 rows = SDDS_RowCount(SDDS_orig);
1111 *colIndex = malloc(sizeof(long) * orig_column_names);
1112 *colIndex2 = malloc(sizeof(double) * orig_column_names);
1113
1114 /* Read all numerical data from file */
1115 for (i = 0; i < orig_column_names; i++) {
1116 (*type)[i] = SDDS_GetNamedColumnType(SDDS_orig, orig_column_name[i]);
1117 if ((*type)[i] == 0) {
1118 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1119 exit(EXIT_FAILURE);
1120 }
1121
1122 switch ((*type)[i]) {
1123 case SDDS_SHORT:
1124 (*data)[i].shortData = SDDS_GetColumn(SDDS_orig, orig_column_name[i]);
1125 break;
1126 case SDDS_USHORT:
1127 (*data)[i].ushortData = SDDS_GetColumn(SDDS_orig, orig_column_name[i]);
1128 break;
1129 case SDDS_LONG:
1130 (*data)[i].longData = SDDS_GetColumn(SDDS_orig, orig_column_name[i]);
1131 break;
1132 case SDDS_ULONG:
1133 (*data)[i].ulongData = SDDS_GetColumn(SDDS_orig, orig_column_name[i]);
1134 break;
1135 case SDDS_LONG64:
1136 (*data)[i].long64Data = SDDS_GetColumn(SDDS_orig, orig_column_name[i]);
1137 break;
1138 case SDDS_ULONG64:
1139 (*data)[i].ulong64Data = SDDS_GetColumn(SDDS_orig, orig_column_name[i]);
1140 break;
1141 case SDDS_FLOAT:
1142 (*data)[i].floatData = SDDS_GetColumn(SDDS_orig, orig_column_name[i]);
1143 break;
1144 case SDDS_DOUBLE:
1145 (*data)[i].doubleData = SDDS_GetColumn(SDDS_orig, orig_column_name[i]);
1146 break;
1147 default:
1148 continue;
1149 }
1150 if (strncmp(colPrefix, orig_column_name[i], strlen(colPrefix)) != 0) {
1151 continue;
1152 }
1153 (*colIndex)[*validColumns] = i;
1154 *validColumns += 1;
1155 }
1156
1157 if (SDDS_Terminate(SDDS_orig) != 1) {
1158 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
1159 exit(EXIT_FAILURE);
1160 }
1161
1162 if (*validColumns == 0) {
1163 fprintf(stderr, "error: no valid columns in image file\n");
1164 exit(EXIT_FAILURE);
1165 }
1166 /* For each valid column read the row from the column name */
1167 for (i = 0; i < *validColumns; i++) {
1168 (*colIndex2)[i] = atof(orig_column_name[(*colIndex)[i]] + strlen(colPrefix));
1169 }
1170 /* Sort columns by their row value ('row' is not related to the SDDS rows) */
1171 for (i = 0; i < *validColumns; i++) {
1172 for (j = i + 1; j < *validColumns; j++) {
1173 if ((*colIndex2)[j] < (*colIndex2)[i]) {
1174 temp = (*colIndex)[i];
1175 temp2 = (*colIndex2)[i];
1176 (*colIndex)[i] = (*colIndex)[j];
1177 (*colIndex2)[i] = (*colIndex2)[j];
1178 (*colIndex)[j] = temp;
1179 (*colIndex2)[j] = temp2;
1180 }
1181 }
1182 }
1183 return rows;
1184}
SDDS_GetColumn
void * SDDS_GetColumn(SDDS_DATASET *SDDS_dataset, char *column_name)
Retrieves a copy of the data for a specified column, including only rows marked as "of interest".
Definition SDDS_extract.c:611
SDDS_InitializeInput
int32_t SDDS_InitializeInput(SDDS_DATASET *SDDS_dataset, char *filename)
Definition SDDS_input.c:49
SDDS_Terminate
int32_t SDDS_Terminate(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1448
SDDS_ReadPage
int32_t SDDS_ReadPage(SDDS_DATASET *SDDS_dataset)
Definition SDDS_input.c:1006
SDDS_GetNamedColumnType
int32_t SDDS_GetNamedColumnType(SDDS_DATASET *SDDS_dataset, char *name)
Retrieves the data type of a column in the SDDS dataset by its name.
Definition SDDS_utils.c:2178
SDDS_GetColumnNames
char ** SDDS_GetColumnNames(SDDS_DATASET *SDDS_dataset, int32_t *number)
Retrieves the names of all columns in the SDDS dataset.
Definition SDDS_utils.c:2460
SDDS_PrintErrors
void SDDS_PrintErrors(FILE *fp, int32_t mode)
Prints recorded error messages to a specified file stream.
Definition SDDS_utils.c:432
SDDS_ULONG
#define SDDS_ULONG
Identifier for the unsigned 32-bit integer data type.
Definition SDDStypes.h:67
SDDS_FLOAT
#define SDDS_FLOAT
Identifier for the float data type.
Definition SDDStypes.h:43
SDDS_ULONG64
#define SDDS_ULONG64
Identifier for the unsigned 64-bit integer data type.
Definition SDDStypes.h:55
SDDS_LONG
#define SDDS_LONG
Identifier for the signed 32-bit integer data type.
Definition SDDStypes.h:61
SDDS_SHORT
#define SDDS_SHORT
Identifier for the signed short integer data type.
Definition SDDStypes.h:73
SDDS_USHORT
#define SDDS_USHORT
Identifier for the unsigned short integer data type.
Definition SDDStypes.h:79
SDDS_DOUBLE
#define SDDS_DOUBLE
Identifier for the double data type.
Definition SDDStypes.h:37
SDDS_LONG64
#define SDDS_LONG64
Identifier for the signed 64-bit integer data type.
Definition SDDStypes.h:49
IMAGE_DATA
Definition sddsimageprofiles.c:92

◆ main()

int main ( int argc,
char ** argv )

Definition at line 120 of file sddsimageprofiles.c.

120 {
121 SDDS_DATASET SDDS_dataset, SDDS_orig, SDDS_bg;
122 long i_arg;
123 SCANNED_ARG *s_arg;
124 IMAGE_DATA *data = NULL, *bg_data = NULL;
125 char *input = NULL, *output = NULL, *colPrefix = NULL, *background = NULL;
126 long profileType = 1, noWarnings = 0, tmpfile_used = 0, method = 0;
127 unsigned long pipeFlags = 0;
128 int64_t rows, bg_rows, j;
129 long i, validColumns = 0, bg_validColumns = 0;
130 int32_t *type = NULL, *bg_type = NULL;
131
132 int64_t rowStart = 1, rowEnd = 0;
133 long columnStart = 1, columnEnd = 0;
134
135 long *colIndex, *bg_colIndex;
136 double *colIndex2, *bg_colIndex2;
137
138 SDDS_RegisterProgramName(argv[0]);
139 argc = scanargs(&s_arg, argc, argv);
140
141 if (argc < 3)
142 bomb(NULL, USAGE);
143
144 for (i_arg = 1; i_arg < argc; i_arg++) {
145 if (s_arg[i_arg].arg_type == OPTION) {
146 switch (match_string(s_arg[i_arg].list[0], option, N_OPTIONS, 0)) {
147 case SET_PROFILETYPE:
148 if (s_arg[i_arg].n_items != 2)
149 SDDS_Bomb("invalid -profileType syntax");
150 if (strcmp("x", s_arg[i_arg].list[1]) == 0)
151 profileType = 1;
152 if (strcmp("y", s_arg[i_arg].list[1]) == 0)
153 profileType = 2;
154 break;
155 case SET_COLPREFIX:
156 if (s_arg[i_arg].n_items != 2)
157 SDDS_Bomb("invalid -columnPrefix syntax");
158 colPrefix = s_arg[i_arg].list[1];
159 break;
160 case SET_METHOD:
161 if (s_arg[i_arg].n_items != 2)
162 SDDS_Bomb("invalid -method syntax");
163 if ((strncasecmp("centralLine", s_arg[i_arg].list[1], strlen(s_arg[i_arg].list[1])) == 0) ||
164 (strncasecmp("centerLine", s_arg[i_arg].list[1], strlen(s_arg[i_arg].list[1])) == 0))
165 method = 1;
166 if (strncasecmp("integrated", s_arg[i_arg].list[1], strlen(s_arg[i_arg].list[1])) == 0)
167 method = 2;
168 if (strncasecmp("averaged", s_arg[i_arg].list[1], strlen(s_arg[i_arg].list[1])) == 0)
169 method = 3;
170 if (strncasecmp("peak", s_arg[i_arg].list[1], strlen(s_arg[i_arg].list[1])) == 0)
171 method = 4;
172 break;
173 case SET_AREAOFINTEREST:
174 if (s_arg[i_arg].n_items != 5)
175 SDDS_Bomb("invalid -areaOfInterest syntax");
176 if (sscanf(s_arg[i_arg].list[1], "%" SCNd64, &rowStart) != 1 || rowStart <= 0)
177 SDDS_Bomb("invalid -areaOfInterest syntax or value");
178 if (sscanf(s_arg[i_arg].list[2], "%" SCNd64, &rowEnd) != 1 || rowEnd <= 0)
179 SDDS_Bomb("invalid -areaOfInterest syntax or value");
180 if (sscanf(s_arg[i_arg].list[3], "%ld", &columnStart) != 1 || columnStart <= 0)
181 SDDS_Bomb("invalid -areaOfInterest syntax or value");
182 if (sscanf(s_arg[i_arg].list[4], "%ld", &columnEnd) != 1 || columnEnd <= 0)
183 SDDS_Bomb("invalid -areaOfInterest syntax or value");
184 break;
185 case SET_BACKGROUND:
186 if (s_arg[i_arg].n_items != 2)
187 SDDS_Bomb("invalid -background syntax");
188 background = s_arg[i_arg].list[1];
189 break;
190 case SET_PIPE:
191 if (!processPipeOption(s_arg[i_arg].list + 1, s_arg[i_arg].n_items - 1, &pipeFlags))
192 SDDS_Bomb("invalid -pipe syntax");
193 break;
194 default:
195 fprintf(stderr, "error: unknown switch: %s\n", s_arg[i_arg].list[0]);
196 exit(EXIT_FAILURE);
197 break;
198 }
199 } else {
200 if (input == NULL)
201 input = s_arg[i_arg].list[0];
202 else if (output == NULL)
203 output = s_arg[i_arg].list[0];
204 else
205 SDDS_Bomb("too many filenames");
206 }
207 }
208
209 if (colPrefix == NULL) {
210 fprintf(stderr, "error: missing columnPrefix\n");
211 exit(EXIT_FAILURE);
212 }
213
214 processFilenames("sddsimageprofiles", &input, &output, pipeFlags, noWarnings, &tmpfile_used);
215
216 /* Read in the image file */
217 rows = GetData(&SDDS_orig, input, &data, &type, &colIndex, &colIndex2, colPrefix, &validColumns);
218
219 if (rows < 0) {
220 fprintf(stderr, "error: no rows in image file\n");
221 exit(EXIT_FAILURE);
222 }
223
224 if (background != NULL) {
225 /* Read in the background image file */
226 bg_rows = GetData(&SDDS_bg, background, &bg_data, &bg_type, &bg_colIndex, &bg_colIndex2, colPrefix, &bg_validColumns);
227 if (rows != bg_rows) {
228 fprintf(stderr, "error: background has a different number of rows\n");
229 exit(EXIT_FAILURE);
230 }
231 if (validColumns != bg_validColumns) {
232 fprintf(stderr, "error: background has a different number of columns\n");
233 exit(EXIT_FAILURE);
234 }
235 /* Subtract the background from the image file */
236 for (i = 0; i < validColumns; i++) {
237 if (type[colIndex[i]] != bg_type[bg_colIndex[i]]) {
238 fprintf(stderr, "error: column types don't match with background image\n");
239 exit(EXIT_FAILURE);
240 }
241 if (colIndex2[i] != bg_colIndex2[i]) {
242 fprintf(stderr, "error: image rows don't match with background image\n");
243 exit(EXIT_FAILURE);
244 }
245 switch (type[colIndex[i]]) {
246 case SDDS_SHORT:
247 for (j = 0; j < rows; j++)
248 data[colIndex[i]].shortData[j] -= bg_data[bg_colIndex[i]].shortData[j];
249 break;
250 case SDDS_USHORT:
251 for (j = 0; j < rows; j++)
252 data[colIndex[i]].ushortData[j] -= bg_data[bg_colIndex[i]].ushortData[j];
253 break;
254 case SDDS_LONG:
255 for (j = 0; j < rows; j++)
256 data[colIndex[i]].longData[j] -= bg_data[bg_colIndex[i]].longData[j];
257 break;
258 case SDDS_ULONG:
259 for (j = 0; j < rows; j++)
260 data[colIndex[i]].ulongData[j] -= bg_data[bg_colIndex[i]].ulongData[j];
261 break;
262 case SDDS_LONG64:
263 for (j = 0; j < rows; j++)
264 data[colIndex[i]].long64Data[j] -= bg_data[bg_colIndex[i]].long64Data[j];
265 break;
266 case SDDS_ULONG64:
267 for (j = 0; j < rows; j++)
268 data[colIndex[i]].ulong64Data[j] -= bg_data[bg_colIndex[i]].ulong64Data[j];
269 break;
270 case SDDS_FLOAT:
271 for (j = 0; j < rows; j++)
272 data[colIndex[i]].floatData[j] -= bg_data[bg_colIndex[i]].floatData[j];
273 break;
274 case SDDS_DOUBLE:
275 for (j = 0; j < rows; j++)
276 data[colIndex[i]].doubleData[j] -= bg_data[bg_colIndex[i]].doubleData[j];
277 break;
278 default:
279 continue;
280 }
281 }
282 }
283
284 /* Initialize the output file and define the columns */
285 if (!SDDS_InitializeOutput(&SDDS_dataset, SDDS_ASCII, 1, NULL, NULL, output)) {
286 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
287 exit(EXIT_FAILURE);
288 }
289
290 if (profileType == 1) {
291 if (SDDS_DefineParameter(&SDDS_dataset, "Zone", NULL, NULL, NULL, NULL, SDDS_STRING, 0) == -1) {
292 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
293 exit(EXIT_FAILURE);
294 }
295 if (SDDS_DefineColumn(&SDDS_dataset, "x", NULL, NULL, NULL, NULL, SDDS_LONG64, 0) == -1) {
296 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
297 exit(EXIT_FAILURE);
298 }
299 if (SDDS_DefineColumn(&SDDS_dataset, "y", NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0) == -1) {
300 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
301 exit(EXIT_FAILURE);
302 }
303 } else {
304 if (SDDS_DefineParameter(&SDDS_dataset, "Zone", NULL, NULL, NULL, NULL, SDDS_STRING, 0) == -1) {
305 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
306 exit(EXIT_FAILURE);
307 }
308 if (SDDS_DefineColumn(&SDDS_dataset, "x", NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0) == -1) {
309 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
310 exit(EXIT_FAILURE);
311 }
312 if (SDDS_DefineColumn(&SDDS_dataset, "y", NULL, NULL, NULL, NULL, SDDS_DOUBLE, 0) == -1) {
313 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
314 exit(EXIT_FAILURE);
315 }
316 }
317 if (SDDS_WriteLayout(&SDDS_dataset) == 0) {
318 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
319 exit(EXIT_FAILURE);
320 }
321
322 if ((rowEnd > rows) || (rowEnd < rowStart))
323 rowEnd = rows;
324
325 if ((columnEnd > validColumns) || (columnEnd < columnStart))
326 columnEnd = validColumns;
327
328 if (profileType == 1) {
329 xImageProfile(data, type, rows, &SDDS_dataset, method, rowStart - 1, rowEnd, columnStart - 1, columnEnd, colIndex, colIndex2);
330 } else {
331 yImageProfile(data, type, rows, &SDDS_dataset, method, rowStart - 1, rowEnd, columnStart - 1, columnEnd, colIndex, colIndex2);
332 }
333
334 /* Close the output file */
335 if (SDDS_Terminate(&SDDS_dataset) != 1) {
336 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
337 exit(EXIT_FAILURE);
338 }
339
340 for (i = 0; i < validColumns; i++) {
341 switch (type[colIndex[i]]) {
342 case SDDS_SHORT:
343 free(data[colIndex[i]].shortData);
344 break;
345 case SDDS_USHORT:
346 free(data[colIndex[i]].ushortData);
347 break;
348 case SDDS_LONG:
349 free(data[colIndex[i]].longData);
350 break;
351 case SDDS_ULONG:
352 free(data[colIndex[i]].ulongData);
353 break;
354 case SDDS_LONG64:
355 free(data[colIndex[i]].long64Data);
356 break;
357 case SDDS_ULONG64:
358 free(data[colIndex[i]].ulong64Data);
359 break;
360 case SDDS_FLOAT:
361 free(data[colIndex[i]].floatData);
362 break;
363 case SDDS_DOUBLE:
364 free(data[colIndex[i]].doubleData);
365 break;
366 default:
367 continue;
368 }
369 }
370 free(data);
371 free(type);
372 if (background != NULL) {
373 for (i = 0; i < validColumns; i++) {
374 switch (bg_type[bg_colIndex[i]]) {
375 case SDDS_SHORT:
376 free(bg_data[bg_colIndex[i]].shortData);
377 break;
378 case SDDS_USHORT:
379 free(bg_data[bg_colIndex[i]].ushortData);
380 break;
381 case SDDS_LONG:
382 free(bg_data[bg_colIndex[i]].longData);
383 break;
384 case SDDS_ULONG:
385 free(bg_data[bg_colIndex[i]].ulongData);
386 break;
387 case SDDS_LONG64:
388 free(bg_data[bg_colIndex[i]].long64Data);
389 break;
390 case SDDS_ULONG64:
391 free(bg_data[bg_colIndex[i]].ulong64Data);
392 break;
393 case SDDS_FLOAT:
394 free(bg_data[bg_colIndex[i]].floatData);
395 break;
396 case SDDS_DOUBLE:
397 free(bg_data[bg_colIndex[i]].doubleData);
398 break;
399 default:
400 continue;
401 }
402 }
403 free(bg_data);
404 free(bg_type);
405 }
406
407 return EXIT_SUCCESS;
408}
SDDS_InitializeOutput
int32_t SDDS_InitializeOutput(SDDS_DATASET *SDDS_dataset, int32_t data_mode, int32_t lines_per_row, const char *description, const char *contents, const char *filename)
Initializes the SDDS output dataset.
Definition SDDS_output.c:601
SDDS_DefineColumn
int32_t SDDS_DefineColumn(SDDS_DATASET *SDDS_dataset, const char *name, const char *symbol, const char *units, const char *description, const char *format_string, int32_t type, int32_t field_length)
Defines a data column within the SDDS dataset.
Definition SDDS_output.c:1715
SDDS_WriteLayout
int32_t SDDS_WriteLayout(SDDS_DATASET *SDDS_dataset)
Writes the SDDS layout header to the output file.
Definition SDDS_output.c:899
SDDS_DefineParameter
int32_t SDDS_DefineParameter(SDDS_DATASET *SDDS_dataset, const char *name, const char *symbol, const char *units, const char *description, const char *format_string, int32_t type, char *fixed_value)
Defines a data parameter with a fixed string value.
Definition SDDS_output.c:1472
SDDS_RegisterProgramName
void SDDS_RegisterProgramName(const char *name)
Registers the executable program name for use in error messages.
Definition SDDS_utils.c:288
SDDS_Bomb
void SDDS_Bomb(char *message)
Terminates the program after printing an error message and recorded errors.
Definition SDDS_utils.c:342
SDDS_STRING
#define SDDS_STRING
Identifier for the string data type.
Definition SDDStypes.h:85
bomb
void bomb(char *error, char *usage)
Reports error messages to the terminal and aborts the program.
Definition bomb.c:26
match_string
long match_string(char *string, char **option, long n_options, long mode)
Matches a given string against an array of option strings based on specified modes.
Definition match_string.c:34
scanargs
int scanargs(SCANNED_ARG **scanned, int argc, char **argv)
Definition scanargs.c:36
processPipeOption
long processPipeOption(char **item, long items, unsigned long *flags)
Definition scanargs.c:356
processFilenames
void processFilenames(char *programName, char **input, char **output, unsigned long pipeFlags, long noWarnings, long *tmpOutputUsed)
Definition scanargs.c:390
SDDS_DATASET
Definition SDDS.h:308

◆ xCenterLine()

int64_t xCenterLine ( IMAGE_DATA * data,
int32_t * type,
long * colIndex,
int64_t x1,
int64_t x2,
long y1,
long y2 )

Definition at line 979 of file sddsimageprofiles.c.

979 {
980 int64_t i, j, start = 1;
981 double val = 0, maxValue = 0;
982 int64_t index = 0;
983
984 for (i = x1; i < x2; i++) {
985 val = 0;
986 for (j = y1; j < y2; j++) {
987 switch (type[colIndex[j]]) {
988 case SDDS_SHORT:
989 val += data[colIndex[j]].shortData[i];
990 break;
991 case SDDS_USHORT:
992 val += data[colIndex[j]].ushortData[i];
993 break;
994 case SDDS_LONG:
995 val += data[colIndex[j]].longData[i];
996 break;
997 case SDDS_ULONG:
998 val += data[colIndex[j]].ulongData[i];
999 break;
1000 case SDDS_LONG64:
1001 val += data[colIndex[j]].long64Data[i];
1002 break;
1003 case SDDS_ULONG64:
1004 val += data[colIndex[j]].ulong64Data[i];
1005 break;
1006 case SDDS_FLOAT:
1007 val += data[colIndex[j]].floatData[i];
1008 break;
1009 case SDDS_DOUBLE:
1010 val += data[colIndex[j]].doubleData[i];
1011 break;
1012 }
1013 }
1014 if (start == 1) {
1015 index = i;
1016 maxValue = val;
1017 start = 0;
1018 } else {
1019 if (val > maxValue) {
1020 index = i;
1021 maxValue = val;
1022 }
1023 }
1024 }
1025 return index;
1026}

◆ xImageProfile()

int xImageProfile ( IMAGE_DATA * data,
int32_t * type,
int64_t rows,
SDDS_DATASET * SDDS_dataset,
long method,
int64_t x1,
int64_t x2,
long y1,
long y2,
long * colIndex,
double * colIndex2 )

Definition at line 410 of file sddsimageprofiles.c.

411 {
412 int64_t i, k = 0;
413 int j;
414 double val = 0;
415 long center;
416 int64_t *index;
417 double *values;
418 char value[100];
419 index = malloc(sizeof(int64_t) * rows);
420 values = malloc(sizeof(double) * rows);
421
422 if (method == 0) { /* Highest point */
423 for (i = x1; i < x2; i++) {
424 switch (type[colIndex[y1]]) {
425 case SDDS_SHORT:
426 val = data[colIndex[y1]].shortData[i];
427 break;
428 case SDDS_USHORT:
429 val = data[colIndex[y1]].ushortData[i];
430 break;
431 case SDDS_LONG:
432 val = data[colIndex[y1]].longData[i];
433 break;
434 case SDDS_ULONG:
435 val = data[colIndex[y1]].ulongData[i];
436 break;
437 case SDDS_LONG64:
438 val = data[colIndex[y1]].long64Data[i];
439 break;
440 case SDDS_ULONG64:
441 val = data[colIndex[y1]].ulong64Data[i];
442 break;
443 case SDDS_FLOAT:
444 val = data[colIndex[y1]].floatData[i];
445 break;
446 case SDDS_DOUBLE:
447 val = data[colIndex[y1]].doubleData[i];
448 break;
449 }
450 for (j = y1 + 1; j < y2; j++) {
451 switch (type[colIndex[j]]) {
452 case SDDS_SHORT:
453 if (val < data[colIndex[j]].shortData[i])
454 val = data[colIndex[j]].shortData[i];
455 break;
456 case SDDS_USHORT:
457 if (val < data[colIndex[j]].ushortData[i])
458 val = data[colIndex[j]].ushortData[i];
459 break;
460 case SDDS_LONG:
461 if (val < data[colIndex[j]].longData[i])
462 val = data[colIndex[j]].longData[i];
463 break;
464 case SDDS_ULONG:
465 if (val < data[colIndex[j]].ulongData[i])
466 val = data[colIndex[j]].ulongData[i];
467 break;
468 case SDDS_LONG64:
469 if (val < data[colIndex[j]].long64Data[i])
470 val = data[colIndex[j]].long64Data[i];
471 break;
472 case SDDS_ULONG64:
473 if (val < data[colIndex[j]].ulong64Data[i])
474 val = data[colIndex[j]].ulong64Data[i];
475 break;
476 case SDDS_FLOAT:
477 if (val < data[colIndex[j]].floatData[i])
478 val = data[colIndex[j]].floatData[i];
479 break;
480 case SDDS_DOUBLE:
481 if (val < data[colIndex[j]].doubleData[i])
482 val = data[colIndex[j]].doubleData[i];
483 break;
484 }
485 }
486 index[k] = i + 1;
487 values[k] = val;
488 k++;
489 }
490 } else if ((method == 1) || (method == 4)) { /* Center line or peak */
491 if (method == 4) {
492 center = yPeakLine(data, type, colIndex, x1, x2, y1, y2);
493 } else {
494 center = yCenterLine(data, type, colIndex, x1, x2, y1, y2);
495 }
496 for (i = x1; i < x2; i++) {
497 switch (type[colIndex[center]]) {
498 case SDDS_SHORT:
499 val = data[colIndex[center]].shortData[i];
500 break;
501 case SDDS_USHORT:
502 val = data[colIndex[center]].ushortData[i];
503 break;
504 case SDDS_LONG:
505 val = data[colIndex[center]].longData[i];
506 break;
507 case SDDS_ULONG:
508 val = data[colIndex[center]].ulongData[i];
509 break;
510 case SDDS_LONG64:
511 val = data[colIndex[center]].long64Data[i];
512 break;
513 case SDDS_ULONG64:
514 val = data[colIndex[center]].ulong64Data[i];
515 break;
516 case SDDS_FLOAT:
517 val = data[colIndex[center]].floatData[i];
518 break;
519 case SDDS_DOUBLE:
520 val = data[colIndex[center]].doubleData[i];
521 break;
522 }
523 index[k] = i + 1;
524 values[k] = val;
525 k++;
526 }
527 } else if ((method == 2) || (method == 3)) { /* Integrated or Averaged profile */
528 for (i = x1; i < x2; i++) {
529 val = 0;
530 for (j = y1; j < y2; j++) {
531 switch (type[colIndex[j]]) {
532 case SDDS_SHORT:
533 val += data[colIndex[j]].shortData[i];
534 break;
535 case SDDS_USHORT:
536 val += data[colIndex[j]].ushortData[i];
537 break;
538 case SDDS_LONG:
539 val += data[colIndex[j]].longData[i];
540 break;
541 case SDDS_ULONG:
542 val += data[colIndex[j]].ulongData[i];
543 break;
544 case SDDS_LONG64:
545 val += data[colIndex[j]].long64Data[i];
546 break;
547 case SDDS_ULONG64:
548 val += data[colIndex[j]].ulong64Data[i];
549 break;
550 case SDDS_FLOAT:
551 val += data[colIndex[j]].floatData[i];
552 break;
553 case SDDS_DOUBLE:
554 val += data[colIndex[j]].doubleData[i];
555 break;
556 }
557 }
558 index[k] = i + 1;
559 if (method == 2)
560 values[k] = val;
561 else
562 values[k] = val / (y2 - y1);
563 k++;
564 }
565 }
566
567 if (SDDS_StartPage(SDDS_dataset, x2 - x1) == 0) {
568 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
569 exit(EXIT_FAILURE);
570 }
571 sprintf(value, "(%" PRId64 ",%ld) x (%" PRId64 ",%ld)", x1 + 1, y1 + 1, x2, y2);
572 if (SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, "Zone", value, NULL) != 1) {
573 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
574 exit(EXIT_FAILURE);
575 }
576 if (SDDS_SetColumn(SDDS_dataset, SDDS_SET_BY_NAME, index, k, "x", NULL) != 1) {
577 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
578 exit(EXIT_FAILURE);
579 }
580 if (SDDS_SetColumn(SDDS_dataset, SDDS_SET_BY_NAME, values, k, "y", NULL) != 1) {
581 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
582 exit(EXIT_FAILURE);
583 }
584 if (SDDS_WritePage(SDDS_dataset) != 1) {
585 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
586 exit(EXIT_FAILURE);
587 }
588 free(index);
589 free(values);
590 return 0;
591}
SDDS_StartPage
int32_t SDDS_StartPage(SDDS_DATASET *SDDS_dataset, int64_t expected_n_rows)
Definition SDDS_dataprep.c:64
SDDS_SetParameters
int32_t SDDS_SetParameters(SDDS_DATASET *SDDS_dataset, int32_t mode,...)
Definition SDDS_dataprep.c:369
SDDS_SetColumn
int32_t SDDS_SetColumn(SDDS_DATASET *SDDS_dataset, int32_t mode, void *data, int64_t rows,...)
Sets the values for one data column in the current data table of an SDDS dataset.
Definition SDDS_dataprep.c:1536
SDDS_WritePage
int32_t SDDS_WritePage(SDDS_DATASET *SDDS_dataset)
Writes the current data table to the output file.
Definition SDDS_output.c:1228

◆ xPeakLine()

int64_t xPeakLine ( IMAGE_DATA * data,
int32_t * type,
long * colIndex,
int64_t x1,
int64_t x2,
long y1,
long y2 )

Definition at line 800 of file sddsimageprofiles.c.

800 {
801 int64_t i, j;
802 double maxValue = 0;
803 int64_t index = 0;
804
805 index = x1;
806 switch (type[colIndex[y1]]) {
807 case SDDS_SHORT:
808 maxValue = data[colIndex[y1]].shortData[x1];
809 break;
810 case SDDS_USHORT:
811 maxValue = data[colIndex[y1]].ushortData[x1];
812 break;
813 case SDDS_LONG:
814 maxValue = data[colIndex[y1]].longData[x1];
815 break;
816 case SDDS_ULONG:
817 maxValue = data[colIndex[y1]].ulongData[x1];
818 break;
819 case SDDS_LONG64:
820 maxValue = data[colIndex[y1]].long64Data[x1];
821 break;
822 case SDDS_ULONG64:
823 maxValue = data[colIndex[y1]].ulong64Data[x1];
824 break;
825 case SDDS_FLOAT:
826 maxValue = data[colIndex[y1]].floatData[x1];
827 break;
828 case SDDS_DOUBLE:
829 maxValue = data[colIndex[y1]].doubleData[x1];
830 break;
831 }
832 for (i = y1; i < y2; i++) {
833 for (j = x1; j < x2; j++) {
834 switch (type[colIndex[i]]) {
835 case SDDS_SHORT:
836 if (maxValue < data[colIndex[i]].shortData[j]) {
837 maxValue = data[colIndex[i]].shortData[j];
838 index = j;
839 }
840 break;
841 case SDDS_USHORT:
842 if (maxValue < data[colIndex[i]].ushortData[j]) {
843 maxValue = data[colIndex[i]].ushortData[j];
844 index = j;
845 }
846 break;
847 case SDDS_LONG:
848 if (maxValue < data[colIndex[i]].longData[j]) {
849 maxValue = data[colIndex[i]].longData[j];
850 index = j;
851 }
852 break;
853 case SDDS_ULONG:
854 if (maxValue < data[colIndex[i]].ulongData[j]) {
855 maxValue = data[colIndex[i]].ulongData[j];
856 index = j;
857 }
858 break;
859 case SDDS_LONG64:
860 if (maxValue < data[colIndex[i]].long64Data[j]) {
861 maxValue = data[colIndex[i]].long64Data[j];
862 index = j;
863 }
864 break;
865 case SDDS_ULONG64:
866 if (maxValue < data[colIndex[i]].ulong64Data[j]) {
867 maxValue = data[colIndex[i]].ulong64Data[j];
868 index = j;
869 }
870 break;
871 case SDDS_FLOAT:
872 if (maxValue < data[colIndex[i]].floatData[j]) {
873 maxValue = data[colIndex[i]].floatData[j];
874 index = j;
875 }
876 break;
877 case SDDS_DOUBLE:
878 if (maxValue < data[colIndex[i]].doubleData[j]) {
879 maxValue = data[colIndex[i]].doubleData[j];
880 index = j;
881 }
882 break;
883 }
884 }
885 }
886 return index;
887}

◆ yCenterLine()

long yCenterLine ( IMAGE_DATA * data,
int32_t * type,
long * colIndex,
int64_t x1,
int64_t x2,
long y1,
long y2 )

Definition at line 1028 of file sddsimageprofiles.c.

1028 {
1029 int i, start = 1;
1030 int64_t j;
1031 double val, maxValue = 0;
1032 long index = 0;
1033
1034 for (i = y1; i < y2; i++) {
1035 val = 0;
1036 for (j = x1; j < x2; j++)
1037 switch (type[colIndex[i]]) {
1038 case SDDS_SHORT:
1039 val += data[colIndex[i]].shortData[j];
1040 break;
1041 case SDDS_USHORT:
1042 val += data[colIndex[i]].ushortData[j];
1043 break;
1044 case SDDS_LONG:
1045 val += data[colIndex[i]].longData[j];
1046 break;
1047 case SDDS_ULONG:
1048 val += data[colIndex[i]].ulongData[j];
1049 break;
1050 case SDDS_LONG64:
1051 val += data[colIndex[i]].long64Data[j];
1052 break;
1053 case SDDS_ULONG64:
1054 val += data[colIndex[i]].ulong64Data[j];
1055 break;
1056 case SDDS_FLOAT:
1057 val += data[colIndex[i]].floatData[j];
1058 break;
1059 case SDDS_DOUBLE:
1060 val += data[colIndex[i]].doubleData[j];
1061 break;
1062 default:
1063 continue;
1064 }
1065 if (start == 1) {
1066 index = i;
1067 maxValue = val;
1068 start = 0;
1069 } else {
1070 if (val > maxValue) {
1071 index = i;
1072 maxValue = val;
1073 }
1074 }
1075 }
1076 return index;
1077}

◆ yImageProfile()

int yImageProfile ( IMAGE_DATA * data,
int32_t * type,
int64_t rows,
SDDS_DATASET * SDDS_dataset,
long method,
int64_t x1,
int64_t x2,
long y1,
long y2,
long * colIndex,
double * colIndex2 )

Definition at line 593 of file sddsimageprofiles.c.

594 {
595 int i, k = 0;
596 int64_t j;
597 double val;
598 int64_t center;
599
600 double *index;
601 double *values;
602 char value[100];
603
604 index = malloc(sizeof(double) * (y2 - y1));
605 values = malloc(sizeof(double) * (y2 - y1));
606
607 if (method == 0) { /* Highest point */
608 for (i = y1; i < y2; i++) {
609 switch (type[colIndex[i]]) {
610 case SDDS_SHORT:
611 val = data[colIndex[i]].shortData[x1];
612 break;
613 case SDDS_USHORT:
614 val = data[colIndex[i]].ushortData[x1];
615 break;
616 case SDDS_LONG:
617 val = data[colIndex[i]].longData[x1];
618 break;
619 case SDDS_ULONG:
620 val = data[colIndex[i]].ulongData[x1];
621 break;
622 case SDDS_LONG64:
623 val = data[colIndex[i]].long64Data[x1];
624 break;
625 case SDDS_ULONG64:
626 val = data[colIndex[i]].ulong64Data[x1];
627 break;
628 case SDDS_FLOAT:
629 val = data[colIndex[i]].floatData[x1];
630 break;
631 case SDDS_DOUBLE:
632 val = data[colIndex[i]].doubleData[x1];
633 break;
634 default:
635 continue;
636 }
637 for (j = x1 + 1; j < x2; j++) {
638 switch (type[colIndex[i]]) {
639 case SDDS_SHORT:
640 if (val < data[colIndex[i]].shortData[j]) {
641 val = data[colIndex[i]].shortData[j];
642 }
643 break;
644 case SDDS_USHORT:
645 if (val < data[colIndex[i]].ushortData[j]) {
646 val = data[colIndex[i]].ushortData[j];
647 }
648 break;
649 case SDDS_LONG:
650 if (val < data[colIndex[i]].longData[j]) {
651 val = data[colIndex[i]].longData[j];
652 }
653 break;
654 case SDDS_ULONG:
655 if (val < data[colIndex[i]].ulongData[j]) {
656 val = data[colIndex[i]].ulongData[j];
657 }
658 break;
659 case SDDS_LONG64:
660 if (val < data[colIndex[i]].long64Data[j]) {
661 val = data[colIndex[i]].long64Data[j];
662 }
663 break;
664 case SDDS_ULONG64:
665 if (val < data[colIndex[i]].ulong64Data[j]) {
666 val = data[colIndex[i]].ulong64Data[j];
667 }
668 break;
669 case SDDS_FLOAT:
670 if (val < data[colIndex[i]].floatData[j]) {
671 val = data[colIndex[i]].floatData[j];
672 }
673 break;
674 case SDDS_DOUBLE:
675 if (val < data[colIndex[i]].doubleData[j]) {
676 val = data[colIndex[i]].doubleData[j];
677 }
678 break;
679 default:
680 continue;
681 }
682 }
683 index[k] = colIndex2[i];
684 values[k] = val;
685 k++;
686 }
687 } else if ((method == 1) || (method == 4)) { /* Center line or peak */
688 if (method == 4) {
689 center = xPeakLine(data, type, colIndex, x1, x2, y1, y2);
690 } else {
691 center = xCenterLine(data, type, colIndex, x1, x2, y1, y2);
692 }
693 for (i = y1; i < y2; i++) {
694 switch (type[colIndex[i]]) {
695 case SDDS_SHORT:
696 val = data[colIndex[i]].shortData[center];
697 break;
698 case SDDS_USHORT:
699 val = data[colIndex[i]].ushortData[center];
700 break;
701 case SDDS_LONG:
702 val = data[colIndex[i]].longData[center];
703 break;
704 case SDDS_ULONG:
705 val = data[colIndex[i]].ulongData[center];
706 break;
707 case SDDS_LONG64:
708 val = data[colIndex[i]].long64Data[center];
709 break;
710 case SDDS_ULONG64:
711 val = data[colIndex[i]].ulong64Data[center];
712 break;
713 case SDDS_FLOAT:
714 val = data[colIndex[i]].floatData[center];
715 break;
716 case SDDS_DOUBLE:
717 val = data[colIndex[i]].doubleData[center];
718 break;
719 default:
720 continue;
721 }
722 index[k] = colIndex2[i];
723 values[k] = val;
724 k++;
725 }
726 } else if ((method == 2) || (method == 3)) { /* Integrated or Averaged profile */
727 for (i = y1; i < y2; i++) {
728 val = 0;
729 switch (type[colIndex[i]]) {
730 case SDDS_SHORT:
731 for (j = x1; j < x2; j++)
732 val += data[colIndex[i]].shortData[j];
733 break;
734 case SDDS_USHORT:
735 for (j = x1; j < x2; j++)
736 val += data[colIndex[i]].ushortData[j];
737 break;
738 case SDDS_LONG:
739 for (j = x1; j < x2; j++)
740 val += data[colIndex[i]].longData[j];
741 break;
742 case SDDS_ULONG:
743 for (j = x1; j < x2; j++)
744 val += data[colIndex[i]].ulongData[j];
745 break;
746 case SDDS_LONG64:
747 for (j = x1; j < x2; j++)
748 val += data[colIndex[i]].long64Data[j];
749 break;
750 case SDDS_ULONG64:
751 for (j = x1; j < x2; j++)
752 val += data[colIndex[i]].ulong64Data[j];
753 break;
754 case SDDS_FLOAT:
755 for (j = x1; j < x2; j++)
756 val += data[colIndex[i]].floatData[j];
757 break;
758 case SDDS_DOUBLE:
759 for (j = x1; j < x2; j++)
760 val += data[colIndex[i]].doubleData[j];
761 break;
762 default:
763 continue;
764 }
765 index[k] = colIndex2[i];
766 if (method == 2)
767 values[k] = val;
768 else
769 values[k] = val / (x2 - x1);
770 k++;
771 }
772 }
773
774 if (SDDS_StartPage(SDDS_dataset, k) == 0) {
775 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
776 exit(EXIT_FAILURE);
777 }
778 sprintf(value, "(%" PRId64 ",%ld) x (%" PRId64 ",%ld)", x1 + 1, y1 + 1, x2, y2);
779 if (SDDS_SetParameters(SDDS_dataset, SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE, "Zone", value, NULL) != 1) {
780 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
781 exit(EXIT_FAILURE);
782 }
783 if (SDDS_SetColumn(SDDS_dataset, SDDS_SET_BY_NAME, index, k, "y", NULL) != 1) {
784 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
785 exit(EXIT_FAILURE);
786 }
787 if (SDDS_SetColumn(SDDS_dataset, SDDS_SET_BY_NAME, values, k, "x", NULL) != 1) {
788 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
789 exit(EXIT_FAILURE);
790 }
791 if (SDDS_WritePage(SDDS_dataset) != 1) {
792 SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
793 exit(EXIT_FAILURE);
794 }
795 free(index);
796 free(values);
797 return 0;
798}

◆ yPeakLine()

long yPeakLine ( IMAGE_DATA * data,
int32_t * type,
long * colIndex,
int64_t x1,
int64_t x2,
long y1,
long y2 )

Definition at line 889 of file sddsimageprofiles.c.

889 {
890 int i;
891 int64_t j;
892 double maxValue = 0;
893 long index = 0;
894
895 index = y1;
896 switch (type[colIndex[y1]]) {
897 case SDDS_SHORT:
898 maxValue = data[colIndex[y1]].shortData[x1];
899 break;
900 case SDDS_USHORT:
901 maxValue = data[colIndex[y1]].ushortData[x1];
902 break;
903 case SDDS_LONG:
904 maxValue = data[colIndex[y1]].longData[x1];
905 break;
906 case SDDS_ULONG:
907 maxValue = data[colIndex[y1]].ulongData[x1];
908 break;
909 case SDDS_LONG64:
910 maxValue = data[colIndex[y1]].long64Data[x1];
911 break;
912 case SDDS_ULONG64:
913 maxValue = data[colIndex[y1]].ulong64Data[x1];
914 break;
915 case SDDS_FLOAT:
916 maxValue = data[colIndex[y1]].floatData[x1];
917 break;
918 case SDDS_DOUBLE:
919 maxValue = data[colIndex[y1]].doubleData[x1];
920 break;
921 }
922 for (i = y1; i < y2; i++) {
923 for (j = x1; j < x2; j++) {
924 switch (type[colIndex[i]]) {
925 case SDDS_SHORT:
926 if (maxValue < data[colIndex[i]].shortData[j]) {
927 maxValue = data[colIndex[i]].shortData[j];
928 index = i;
929 }
930 break;
931 case SDDS_USHORT:
932 if (maxValue < data[colIndex[i]].ushortData[j]) {
933 maxValue = data[colIndex[i]].ushortData[j];
934 index = i;
935 }
936 break;
937 case SDDS_LONG:
938 if (maxValue < data[colIndex[i]].longData[j]) {
939 maxValue = data[colIndex[i]].longData[j];
940 index = i;
941 }
942 break;
943 case SDDS_ULONG:
944 if (maxValue < data[colIndex[i]].ulongData[j]) {
945 maxValue = data[colIndex[i]].ulongData[j];
946 index = i;
947 }
948 break;
949 case SDDS_LONG64:
950 if (maxValue < data[colIndex[i]].long64Data[j]) {
951 maxValue = data[colIndex[i]].long64Data[j];
952 index = i;
953 }
954 break;
955 case SDDS_ULONG64:
956 if (maxValue < data[colIndex[i]].ulong64Data[j]) {
957 maxValue = data[colIndex[i]].ulong64Data[j];
958 index = i;
959 }
960 break;
961 case SDDS_FLOAT:
962 if (maxValue < data[colIndex[i]].floatData[j]) {
963 maxValue = data[colIndex[i]].floatData[j];
964 index = i;
965 }
966 break;
967 case SDDS_DOUBLE:
968 if (maxValue < data[colIndex[i]].doubleData[j]) {
969 maxValue = data[colIndex[i]].doubleData[j];
970 index = i;
971 }
972 break;
973 }
974 }
975 }
976 return index;
977}
Generated by doxygen 1.12.0