/* * ESC * v <nbytes> W * * This command creates only the basic element of the the palette: the cid_data * array. Other parts are created as needed. */ static int pcl_configure_image_data(pcl_args_t * pargs, pcl_state_t * pcs) { if (pcs->personality == pcl5e || pcs->raster_state.graphics_mode) return 0; #ifdef DEBUG if (gs_debug_c('i')) { pcl_debug_dump_data(pcs->memory, arg_data(pargs), uint_arg(pargs)); } #endif return install_cid_data(uint_arg(pargs), arg_data(pargs), pcs, false, false); }
/* * ESC * i <nbytes> W * * Set viewing illuminant. This command is related to the configure image * data object only in the sense that both apply to palettes. The command * is implemented in this file as it is the only other command that involves * binary floating point number arrays. * * This routine will convert the whitepoint to the form anticipated by the * gs_cie_render structure (i.e., Y = 1.0). */ static int set_view_illuminant(pcl_args_t * pargs, pcl_state_t * pcs) { uint len = uint_arg(pargs); const byte *pbuff = arg_data(pargs); float x, y; gs_vector3 wht_pt; if (pcs->personality == pcl5e || pcs->raster_state.graphics_mode) return 0; if (len != 8) return e_Range; x = make_float(pbuff); y = make_float(pbuff + 4); /* * A white point must have a non-zero y value, as otherwise it carries * no chromaticity infomration. It should also have x >= 0, y > 0, and * x + y <= 1, for otherwise it represents an unrealizable color. */ if ((x < 0.0) || (y <= 0.0) || (x + y > 1.0)) return e_Range; wht_pt.u = x / y; wht_pt.v = 1.0; wht_pt.w = (1.0 - x - y) / y; return pcl_palette_set_view_illuminant(pcs, &wht_pt); }
MStatus CheckMeshCmd::ParseArgs(const MArgList& args) { MArgDatabase arg_data(syntax(), args); { if (arg_data.isFlagSet(kToleranceName.c_str())) { auto status = arg_data.getFlagArgument(kToleranceName.c_str(), 0, tolerance_); if (status != MS::kSuccess) { std::cerr << "Invalid argument.\n"; return status; } } } { if (arg_data.isFlagSet(kModeName.c_str())) { auto status = arg_data.getFlagArgument(kModeName.c_str(), 0, mode_); if (status != MS::kSuccess) { std::cerr << "Invalid argument.\n"; return status; } } else { return MS::kInvalidParameter; } } { if (mode_function_map_.find(mode_.asChar()) == mode_function_map_.end()) { return MS::kInvalidParameter; } } { MStringArray string_objects; auto status = arg_data.getObjects(string_objects); if (string_objects.length() > 0) { for (auto index = 0; index < string_objects.length(); ++index) { auto object_name = string_objects[index]; status = MGlobal::getSelectionListByName(object_name, selections_); if (status != MS::kSuccess) { std::cerr << "Invalid argument.\n"; return status; } } } else { status = MGlobal::getActiveSelectionList(selections_); if (status != MS::kSuccess) { std::cerr << "Invalid argument.\n"; return status; } } } return MS::kSuccess; }
static int set_logical_page(pcl_args_t * pargs, pcl_state_t * pcs) { uint count = uint_arg(pargs); const pcl_logical_page_t *plogpage = (pcl_logical_page_t *) arg_data(pargs); pcl_paper_size_t *pcur_paper; #ifdef DEBUG if (gs_debug_c('i')) { pcl_debug_dump_data(pcs->memory, arg_data(pargs), uint_arg(pargs)); } #endif /* the currently selected paper size */ pcur_paper = (pcl_paper_size_t *) pcs->xfm_state.paper_size; /* the command can set width, height and offsets (10) or just offsets (4) */ if (count != 10 && count != 4) return e_Range; if (count == 10) { pcur_paper->width = pl_get_uint16(plogpage->Width) * 10; pcur_paper->height = pl_get_uint16(plogpage->Height) * 10; if (pcur_paper->width == 0 || pcur_paper->height == 0) return e_Range; } pcur_paper->offset_portrait = pl_get_int16(plogpage->LeftOffset) * 10; pcur_paper->offset_landscape = pl_get_int16(plogpage->TopOffset) * 10; new_page_size(pcs, pcur_paper, false, false); gs_erasepage(pcs->pgs); pcs->page_marked = false; return 0; }
static int set_logical_page( pcl_args_t * pargs, pcl_state_t * pcs ) { uint count = uint_arg(pargs); const pcl_logical_page_t *plogpage = (pcl_logical_page_t *)arg_data(pargs); if (count != 10) return e_Range; return 0; }
/* * ESC & b <count> W */ static int pcl_appletalk_configuration( pcl_args_t * pargs, pcl_state_t * pcs ) { const byte * data = arg_data(pargs); uint count = uint_arg(pargs); uint i; if ((count < 2) || (data[0] == ' ')) return e_Range; /* split the string at the first space */ for (i = 1; data[i] != ' '; ++i) { if (i == count - 1) return e_Range; } if (pcs->configure_appletalk == 0) return 0; return (*pcs->configure_appletalk)(data, i, data + i + 1, count - (i + 1)); }
MStatus VDBQueryCmd::doIt(const MArgList& args) { MStatus status = MS::kSuccess; MArgDatabase arg_data(syntax(), args); // always open new files to simplify code, it's cheap anyhow std::vector<std::string> vdb_paths; if (arg_data.isFlagSet(node_short_flag)) { MSelectionList slist; arg_data.getFlagArgument(node_short_flag, 0, slist); MObject node; slist.getDependNode(0, node); MFnDependencyNode dnode(node, &status); if (!status) return status; if (dnode.typeName() != VDBVisualizerShape::typeName) { MGlobal::displayError("[openvdb] Wrong node was passed to the command : " + dnode.name()); return MS::kFailure; } if (arg_data.isFlagSet(current_frame_short_flag)) vdb_paths.push_back(MPlug(node, VDBVisualizerShape::s_out_vdb_path).asString().asChar()); else { build_file_list(MPlug(node, VDBVisualizerShape::s_vdb_path).asString().asChar(), MPlug(node, VDBVisualizerShape::s_cache_playback_start).asInt(), MPlug(node, VDBVisualizerShape::s_cache_playback_end).asInt(), vdb_paths); } } else if (arg_data.isFlagSet(file_short_flag)) { MString vdb_path; arg_data.getFlagArgument(file_short_flag, 0, vdb_path); if (arg_data.isFlagSet(current_frame_short_flag)) { const int current_frame = static_cast<int>(MAnimControl::currentTime().as(MTime::uiUnit())); build_file_list(vdb_path.asChar(), current_frame, current_frame, vdb_paths); } else { int start_frame = 0; int end_frame = 0; if (arg_data.isFlagSet(start_frame_short_flag)) arg_data.getFlagArgument(start_frame_short_flag, 0, start_frame); else start_frame = static_cast<int>(MAnimControl::animationStartTime().as(MTime::uiUnit())); if (arg_data.isFlagSet(end_frame_short_flag)) arg_data.getFlagArgument(end_frame_short_flag, 0, end_frame); else end_frame = static_cast<int>(MAnimControl::animationEndTime().as(MTime::uiUnit())); build_file_list(vdb_path.asChar(), start_frame, end_frame, vdb_paths); } } else { MGlobal::displayError("[openvdb] No cache was passed to the command, use the -file(f) or the -node(n) flags"); return MS::kFailure; } if (vdb_paths.size() == 0) { MGlobal::displayError("[openvdb] No paths are passed to the command."); return MS::kFailure; } std::vector<openvdb::io::File*> vdb_files; vdb_files.reserve(vdb_paths.size()); MString query_type = ""; if (arg_data.isFlagSet(query_short_flag)) arg_data.getFlagArgument(query_short_flag, 0, query_type); else { MGlobal::displayError("[openvdb] No query is specified."); return MS::kFailure; } auto get_array_from_flag = [&](const char* flag_name, std::vector<std::string>& out_values) { if (arg_data.isFlagSet(flag_name)) { MString flag_data; arg_data.getFlagArgument(flag_name, 0, flag_data); MStringArray flags; if (flag_data.index(',')) flag_data.split(',', flags); else if (flag_data.index(';')) flag_data.split(';', flags); else if (flag_data.index(':')) flag_data.split(':', flags); else if (flag_data.index(' ')) flag_data.split(' ', flags); else flags.append(flag_data); const unsigned int flag_count = flags.length(); out_values.reserve(flag_count); for (unsigned int f = 0; f < flag_count; ++f) out_values.push_back(flags[f].asChar()); } }; std::vector<std::string> queries; get_array_from_flag(query_short_flag, queries); if (queries.size() == 0) { MGlobal::displayError("[openvdb] No queries are specified!"); return MS::kFailure; } for (auto vdb_path : vdb_paths) { openvdb::io::File* vdb_file = new openvdb::io::File(vdb_path); vdb_file->open(false); if (vdb_file->isOpen()) vdb_files.push_back(vdb_file); else delete vdb_file; } if (vdb_files.size() == 0) { MGlobal::displayError("[openvdb] No vdb files can be opened."); return MS::kFailure; } std::vector<std::string> grid_names; get_array_from_flag(grid_short_flag, grid_names); std::vector<std::string> grid_types; get_array_from_flag(grid_type_short_flag, grid_types); const bool all_grids = grid_names.size() == 0 && grid_types.size() == 0; auto grid_required = [&](openvdb::GridBase::ConstPtr grid) -> bool { if (all_grids) return true; else { return std::find(grid_names.begin(), grid_names.end(), grid->getName()) != grid_names.end() || std::find(grid_types.begin(), grid_types.end(), grid->valueType()) != grid_types.end(); } }; for (auto query : queries) { if (query == query_type_bbox) { MBoundingBox bbox; for (auto vdb_file : vdb_files) { openvdb::GridPtrVecPtr grids = vdb_file->readAllGridMetadata(); for (openvdb::GridPtrVec::const_iterator it = grids->begin(); it != grids->end(); ++it) { if (openvdb::GridBase::ConstPtr grid = *it) { if (grid_required(grid)) read_transformed_bounding_box(grid, bbox); } } } const MPoint min = bbox.min(); const MPoint max = bbox.max(); appendToResult(min.x); appendToResult(min.y); appendToResult(min.z); appendToResult(max.x); appendToResult(max.y); appendToResult(max.z); } else if (query == query_type_min_max) { std::vector<double> mins; std::vector<double> maxs; for (auto vdb_file : vdb_files) { openvdb::GridPtrVecPtr grids = vdb_file->readAllGridMetadata(); for (openvdb::GridPtrVec::const_iterator it = grids->begin(); it != grids->end(); ++it) { if (openvdb::GridBase::ConstPtr grid = *it) { if (grid_required(grid)) { // TODO: check for the minimum and maximum metadata if (grid->valueType() == "float") { if (mins.size() < 1) mins.resize(1, std::numeric_limits<double>::max()); if (maxs.size() < 1) maxs.resize(1, std::numeric_limits<double>::min()); openvdb::FloatGrid::ConstPtr grid_data = openvdb::gridConstPtrCast<openvdb::FloatGrid>(vdb_file->readGrid(grid->getName())); for (auto iter = grid_data->beginValueOn(); iter; ++iter) { const double value = static_cast<double>(iter.getValue()); mins[0] = std::min(mins[0], value); maxs[0] = std::max(maxs[0], value); } } else if (grid->valueType() == "vec3s") { if (mins.size() < 3) mins.resize(3, std::numeric_limits<double>::max()); if (maxs.size() < 3) maxs.resize(3, std::numeric_limits<double>::min()); openvdb::Vec3SGrid::ConstPtr grid_data = openvdb::gridConstPtrCast<openvdb::Vec3SGrid>(vdb_file->readGrid(grid->getName())); for (auto iter = grid_data->beginValueOn(); iter; ++iter) { const openvdb::Vec3d value = iter.getValue(); mins[0] = std::min(mins[0], value.x()); mins[1] = std::min(mins[1], value.y()); mins[2] = std::min(mins[2], value.z()); maxs[0] = std::max(maxs[0], value.x()); maxs[1] = std::max(maxs[1], value.y()); maxs[2] = std::max(maxs[2], value.z()); } } } } } } for (auto mn : mins) appendToResult(mn); for (auto mx : maxs) appendToResult(mx); } } for (auto vdb_file : vdb_files) delete vdb_file; return status; }
/* * ESC * l <nbytes> W * * Set color lookup table. */ static int set_lookup_tbl(pcl_args_t * pargs, pcl_state_t * pcs) { uint len = uint_arg(pargs); pcl_lookup_tbl_t *plktbl = 0; pcl__lookup_tbl_t *ptbl = 0; int code = 0; #ifdef DEBUG if (gs_debug_c('i')) { pcl_debug_dump_data(pcs->memory, arg_data(pargs), uint_arg(pargs)); } #endif if (pcs->personality == pcl5e || pcs->raster_state.graphics_mode) return 0; /* check for clearing of lookup tables, and for incorrect size */ if (len == 0) return pcl_palette_set_lookup_tbl(pcs, NULL); else if (len != sizeof(pcl__lookup_tbl_t)) return e_Range; rc_alloc_struct_1(plktbl, pcl_lookup_tbl_t, &st_lookup_tbl_t, pcs->memory, return e_Memory, "set color lookup table"); plktbl->rc.free = free_lookup_tbl; plktbl->ptbl = 0; /* either take possession of buffer, or allocate a new one */ if (pargs->data_on_heap) { ptbl = (pcl__lookup_tbl_t *) arg_data(pargs); arg_data(pargs) = 0; } else { ptbl = (pcl__lookup_tbl_t *) gs_alloc_bytes(pcs->memory, sizeof(pcl__lookup_tbl_t), "set color lookup table"); if (ptbl == 0) { free_lookup_tbl(plktbl->rc.memory, plktbl, "set color lookup table"); return e_Memory; } memcpy(ptbl, arg_data(pargs), sizeof(pcl__lookup_tbl_t)); } plktbl->ptbl = ptbl; /* for the CMY color space, convert to RGB color space */ if (pcl_lookup_tbl_get_cspace(plktbl) == pcl_cspace_CMY) { int i; for (i = 0; i < 128; i++) { byte b1 = ptbl->data[i]; byte b2 = ptbl->data[255 - i]; ptbl->data[i] = 255 - b2; ptbl->data[255 - i] = 255 - b1; } ptbl->cspace = (byte) pcl_cspace_RGB; } /* update the current palette; release our reference to the lookup table */ code = pcl_palette_set_lookup_tbl(pcs, plktbl); pcl_lookup_tbl_release(plktbl); return code; }