/*
* 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;
}
