void ImageHeader::write(std::ofstream& f, bool force_reversed) {
float tmp;
unsigned tmpSize;
if (get_number_of_rows() == 0 || get_number_of_columns() == 0 ||
get_number_of_slices() == 0) {
return;
}
// Set consistent header before saving
set_header();
set_time();
set_date();
// Write header
if (algebra::xorT(reversed_, force_reversed)) {
reversed_ = true;
IMP::algebra::reversed_write(&spider_header_, sizeof(float), 36, f, true);
IMP::algebra::reversed_write(&spider_header_.fGeo_matrix, sizeof(double), 9,
f, true);
// 14 is the number of float fields after fGeo_matrix in the header__ struct
IMP::algebra::reversed_write(&spider_header_.fAngle1, sizeof(float), 14, f,
true);
// 752 is the number of chars to the end of the file
f.write(spider_header_.empty, sizeof(char) * 752);
} else {
reversed_ = false;
f.write(reinterpret_cast<char*>(&spider_header_), sizeof(SpiderHeader));
}
// Write empty filling space (filled with zeros)
tmpSize = get_spider_header_size(); // Size of whole header
tmpSize -= sizeof(SpiderHeader); // Decrease the real header
tmp = (float)0.0;
for (unsigned i = 0; i < tmpSize / 4; i++) {
f.write(reinterpret_cast<char*>(&tmp), sizeof(float));
}
}
__declspec( dllexport ) void get_table_strings(HMODULE oleAccModule, HWND controlHwnd, void **tableStrings, long *numberOfRowsOut, long *numberOfColumnsOut) {
// * to *[] to *[] to * string
IAccessible *pAccessible ;
LPFNACCESSIBLEOBJECTFROMWINDOW lpfnAccessibleObjectFromWindow ;
lpfnAccessibleObjectFromWindow = (LPFNACCESSIBLEOBJECTFROMWINDOW)GetProcAddress(oleAccModule, "AccessibleObjectFromWindow");
if (HRESULT hResult = lpfnAccessibleObjectFromWindow(controlHwnd, OBJID_CLIENT, IID_IAccessible, (void**)&pAccessible) == S_OK) {
int numberOfRows = get_number_of_rows(pAccessible) ; // including the header
long numberOfColumns = 3 ;
char ***table_rows ;
char **pHeaderNames ;
find_column_headers(pAccessible, &pHeaderNames, &numberOfColumns) ;
table_rows = (char ***)malloc(sizeof(char*) * numberOfRows) ;
table_rows[0] = pHeaderNames ;
for (int row = 1; row < numberOfRows; row++) {
char **table_row = (char **)malloc(sizeof(char*) * numberOfColumns) ;
char *mainItem = (char *)malloc(sizeof(char) * BUFFER_SIZE) ;
get_name(row, pAccessible, mainItem) ;
char *description = (char *)malloc(sizeof(char) * 2048) ;
get_description(row, pAccessible, description) ;
char *token ;
if (strlen(description) > 0)
token = strtok(description, ",") ;
else
token = NULL ;
for (int column = 0; column < numberOfColumns; column++) {
if (column == 0)
table_row[column] = mainItem ;
else {
char *item = (char *)malloc(sizeof(char) * BUFFER_SIZE) ;
if (token != NULL) {
strcpy(item, token) ;
token = strtok(NULL, ",") ;
} else
strcpy(item, "\0") ;
table_row[column] = remove_column_header_name(pHeaderNames[column], trimwhitespace(item)) ;
}
}
table_rows[row] = table_row ;
}
*tableStrings = table_rows ;
*numberOfRowsOut = numberOfRows ;
*numberOfColumnsOut = numberOfColumns ;
} else {
*numberOfRowsOut = 0 ;
*numberOfColumnsOut = 0 ;
}
}
int main(int argc, char * argv[])
{
if (argc != 2) {printf("Please provide a matrix");}
int ierr = MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank); //sets rank
MPI_Comm_size(MPI_COMM_WORLD, &size); //gets number of processes
current_pivot = 0;
if (rank == 0) { //master process
get_number_of_rows(argv[1], &numrows);
numcols = numrows + 1; //specified by assignment
int i;
for (i = 1; i < size; i++) { //sending out information to slaves about what rows they are reading.
MPI_Isend(&numrows, 1, MPI_INT, i, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD, &request);
}
}
else {
MPI_Recv(&numrows, 1, MPI_INT, 0, MASTER_TO_SLAVE_TAG, MPI_COMM_WORLD, &status);
numcols = numrows + 1;
}
if (rank >= numrows) {
ierr = MPI_Finalize();
return 0;
} else if (rank < (numrows % size)) {
numrows = (numrows / size) + 1;
} else {
numrows = (numrows / size);
}
matrix = allocate_matrix(numrows, numcols);
read_rows(argv[1], matrix);
RREF(matrix);
absolute(matrix, &numrows, &numcols);
reduction(matrix, &numrows, &numcols);
get_best_threshold();
collect(matrix);
// print_matrix(matrix, numrows, numcols);
print_matrix(final_matrix, numcols - 1, numcols);
if (rank == 0) {
// output_to_file(final_matrix);
}
free_matrix(matrix, &numrows);
ierr = MPI_Finalize();
}
