StratifiedSampler(const ParamSet& paramSet)
{
size_t desiredSampleCount = (size_t) paramSet.getInteger("sampleCount", 1);
size_t i = 1;
while (i * i < desiredSampleCount)
++i;
m_resolution = i;
m_sampleCount = m_resolution * m_resolution;
if (m_sampleCount != desiredSampleCount)
std::cout << "Sample count should be a perfect square -- rounding to "
<< m_sampleCount << std::endl;
m_depth = paramSet.getInteger("depth", 3);
m_permutations1D = new size_t*[m_depth];
m_permutations2D = new size_t*[m_depth];
for (int i = 0; i < m_depth; ++i)
{
m_permutations1D[i] = new size_t[m_sampleCount];
m_permutations2D[i] = new size_t[m_sampleCount];
}
m_invResolution = 1.0f / (float)m_resolution;
m_invResolutionSquare = 1.0f / (float) m_sampleCount;
m_random = new Random();
m_sampleIndex = 0;
}
HeterogeneousMedium(const ParamSet& paramSet)
{
m_albedo = paramSet.getColor("albedo");
m_filename = paramSet.getString("filename");
m_densityMultiplier = paramSet.getFloat("densityMultiplier", 1.0f);
m_worldToMedium = paramSet.getTransform("toWorld", Transform()).inverse();
}
void LuxRenderer::createAreaLightMesh(mtlu_MayaObject *obj)
{
MString meshName("");
MFnDependencyNode depFn(obj->mobject);
MObject otherSideObj = getOtherSideNode(MString("mtlu_areaLight_geo"), obj->mobject);
if( otherSideObj != MObject::kNullObj)
{
}else{
int indices[6] = {0,1,2,2,3,0};
float floatPointArray[12] = {-1, -1, 0,
-1, 1, 0,
1, 1, 0,
1, -1, 0};
float floatNormalArray[12] = {0,0,-1,
0,0,-1,
0,0,-1,
0,0,-1};
ParamSet triParams = CreateParamSet();
triParams->AddInt("indices", indices, 6);
triParams->AddPoint("P", floatPointArray, 4);
triParams->AddNormal("N", floatNormalArray, 4);
lux->transformBegin();
float fm[16];
MMatrix tm = obj->transformMatrices[0];
setZUp(tm, fm);
this->lux->transform(fm);
this->lux->shape("trianglemesh", boost::get_pointer(triParams));
lux->transformEnd();
}
}
std::shared_ptr<PointLight> CreatePointLight(const Transform &light2world,
const Medium *medium,
const ParamSet ¶mSet) {
Spectrum I = paramSet.FindOneSpectrum("I", Spectrum(1.0));
Spectrum sc = paramSet.FindOneSpectrum("scale", Spectrum(1.0));
Point3f P = paramSet.FindOnePoint3f("from", Point3f(0, 0, 0));
Transform l2w = Translate(Vector3f(P.x, P.y, P.z)) * light2world;
return std::make_shared<PointLight>(l2w, medium, I * sc);
}
std::shared_ptr<GonioPhotometricLight> CreateGoniometricLight(
const Transform &light2world, const Medium *medium,
const ParamSet ¶mSet) {
Spectrum I = paramSet.FindOneSpectrum("I", Spectrum(1.0));
Spectrum sc = paramSet.FindOneSpectrum("scale", Spectrum(1.0));
std::string texname = paramSet.FindOneFilename("mapname", "");
return std::make_shared<GonioPhotometricLight>(light2world, medium, I * sc,
texname);
}
std::shared_ptr<DistantLight> CreateDistantLight(const Transform &light2world,
const ParamSet ¶mSet) {
Spectrum L = paramSet.FindOneSpectrum("L", Spectrum(1.0));
Spectrum sc = paramSet.FindOneSpectrum("scale", Spectrum(1.0));
Point3f from = paramSet.FindOnePoint3f("from", Point3f(0, 0, 0));
Point3f to = paramSet.FindOnePoint3f("to", Point3f(0, 0, 1));
Vector3f dir = from - to;
return std::make_shared<DistantLight>(light2world, L * sc, dir);
}
std::shared_ptr<InfiniteAreaLight> CreateInfiniteLight(
const Transform &light2world, const ParamSet ¶mSet) {
Spectrum L = paramSet.FindOneSpectrum("L", Spectrum(1.0));
Spectrum sc = paramSet.FindOneSpectrum("scale", Spectrum(1.0));
std::string texmap = paramSet.FindOneFilename("mapname", "");
int nSamples = paramSet.FindOneInt("nsamples", 1);
if (PbrtOptions.quickRender) nSamples = std::max(1, nSamples / 4);
return std::make_shared<InfiniteAreaLight>(light2world, L * sc, nSamples,
texmap);
}
std::shared_ptr<ProjectionLight> CreateProjectionLight(
const Transform &light2world, const Medium *medium,
const ParamSet ¶mSet) {
Spectrum I = paramSet.FindOneSpectrum("I", Spectrum(1.0));
Spectrum sc = paramSet.FindOneSpectrum("scale", Spectrum(1.0));
Float fov = paramSet.FindOneFloat("fov", 45.);
std::string texname = paramSet.FindOneFilename("mapname", "");
return std::make_shared<ProjectionLight>(light2world, medium, I * sc,
texname, fov);
}
std::shared_ptr<Shape> CreateHyperboloidShape(const Transform *o2w,
const Transform *w2o,
bool reverseOrientation,
const ParamSet ¶ms) {
Point3f p1 = params.FindOnePoint3f("p1", Point3f(0, 0, 0));
Point3f p2 = params.FindOnePoint3f("p2", Point3f(1, 1, 1));
Float phimax = params.FindOneFloat("phimax", 360);
return std::make_shared<Hyperboloid>(o2w, w2o, reverseOrientation, p1, p2,
phimax);
}
std::shared_ptr<AreaLight> CreateDiffuseAreaLight(
const Transform &light2world, const Medium *medium,
const ParamSet ¶mSet, const std::shared_ptr<Shape> &shape) {
Spectrum L = paramSet.FindOneSpectrum("L", Spectrum(1.0));
Spectrum sc = paramSet.FindOneSpectrum("scale", Spectrum(1.0));
int nSamples = paramSet.FindOneInt("nsamples", 1);
if (PbrtOptions.quickRender) nSamples = std::max(1, nSamples / 4);
return std::make_shared<DiffuseAreaLight>(light2world, medium, L * sc,
nSamples, shape);
}
std::shared_ptr<Cylinder> CreateCylinderShape(const Transform *o2w,
const Transform *w2o,
bool reverseOrientation,
const ParamSet ¶ms) {
Float radius = params.FindOneFloat("radius", 1);
Float zmin = params.FindOneFloat("zmin", -1);
Float zmax = params.FindOneFloat("zmax", 1);
Float phimax = params.FindOneFloat("phimax", 360);
return std::make_shared<Cylinder>(o2w, w2o, reverseOrientation, radius,
zmin, zmax, phimax);
}
std::shared_ptr<Disk> CreateDiskShape(const Transform *o2w,
const Transform *w2o,
bool reverseOrientation,
const ParamSet ¶ms) {
Float height = params.FindOneFloat("height", 0.);
Float radius = params.FindOneFloat("radius", 1);
Float inner_radius = params.FindOneFloat("innerradius", 0);
Float phimax = params.FindOneFloat("phimax", 360);
return std::make_shared<Disk>(o2w, w2o, reverseOrientation, height, radius,
inner_radius, phimax);
}
GaussianFilter(const ParamSet& paramSet)
{
float radius = paramSet.getFloat("radius", 2.0f);
m_size.x = m_size.y = radius;
float stddev = paramSet.getFloat("stddev", 0.5f);
m_alpha = 1.0f / (2.0f * stddev * stddev);
m_expX = exp(-m_alpha * m_size.x * m_size.x);
m_expY = exp(-m_alpha * m_size.y * m_size.y);
}
std::shared_ptr<Shape> CreateSphereShape(const Transform *o2w,
const Transform *w2o,
bool reverseOrientation,
const ParamSet ¶ms) {
Float radius = params.FindOneFloat("radius", 1.f);
Float zmin = params.FindOneFloat("zmin", -radius);
Float zmax = params.FindOneFloat("zmax", radius);
Float phimax = params.FindOneFloat("phimax", 360.f);
return std::make_shared<Sphere>(o2w, w2o, reverseOrientation, radius, zmin,
zmax, phimax);
}
inline ParamSet evaluatedOverrindingParams(ParamSet eventContext,
TaskInstance instance) const {
ParamSet overridingParams;
TaskInstancePseudoParamsProvider ppp = instance.pseudoParams();
ParamsProviderMerger ppm = ParamsProviderMerger(eventContext)(&ppp);
foreach (QString key, _overridingParams.keys())
overridingParams.setValue(key, _overridingParams.value(key, &ppm));
//Log::fatal() << "******************* " << eventContext << overridingParams
// << _overridingParams;
return overridingParams;
}
WISP_NAMESPACE_BEGIN
Light::Light(const ParamSet& paramSet)
{
m_lightToWorld = paramSet.getTransform("toWorld", Transform());
m_worldToLight = m_lightToWorld.inverse();
m_intersectable = false;
}
void trigger(EventSubscription subscription, ParamSet eventContext,
TaskInstance parentInstance) const {
if (_scheduler) {
QString id;
if (parentInstance.isNull()) {
id = _id;
} else {
TaskInstancePseudoParamsProvider ppp = parentInstance.pseudoParams();
id = eventContext.evaluate(_id, &ppp);
QString idIfLocalToGroup = parentInstance.task().taskGroup().id()
+"."+_id;
if (_scheduler->taskExists(idIfLocalToGroup))
id = idIfLocalToGroup;
}
TaskInstanceList instances = _scheduler->syncRequestTask(
id, evaluatedOverrindingParams(eventContext, parentInstance), _force,
parentInstance);
if (instances.isEmpty())
Log::error(parentInstance.task().id(), parentInstance.idAsLong())
<< "requesttask action failed to request execution of task "
<< id << " within event subscription context "
<< subscription.subscriberName() << "|" << subscription.eventName();
else
foreach (TaskInstance childInstance, instances)
Log::info(parentInstance.task().id(), parentInstance.idAsLong())
<< "requesttask action requested execution of task "
<< childInstance.task().id() << "/" << childInstance.groupId();
}
}
std::shared_ptr<Light> MakeLight(const std::string &name,
const ParamSet ¶mSet,
const Transform &light2world,
const MediumInterface &mediumInterface) {
std::shared_ptr<Light> light;
if (name == "point")
light =
CreatePointLight(light2world, mediumInterface.outside, paramSet);
else if (name == "spot")
light = CreateSpotLight(light2world, mediumInterface.outside, paramSet);
else if (name == "goniometric")
light = CreateGoniometricLight(light2world, mediumInterface.outside,
paramSet);
else if (name == "projection")
light = CreateProjectionLight(light2world, mediumInterface.outside,
paramSet);
else if (name == "distant")
light = CreateDistantLight(light2world, paramSet);
else if (name == "infinite" || name == "exinfinite")
light = CreateInfiniteLight(light2world, paramSet);
else
Warning("Light \"%s\" unknown.", name.c_str());
paramSet.ReportUnused();
return light;
}
void LuxRenderer::defineFilm()
{
int width = this->mtlu_renderGlobals->imgWidth;
int height = this->mtlu_renderGlobals->imgHeight;
MString outputPath = this->mtlu_renderGlobals->basePath + "/" + this->mtlu_renderGlobals->imageName + "." + (int)this->mtlu_renderGlobals->currentFrame + ".lxs";
// file path without extension, will be added automatically by the renderer
MString fileName = this->mtlu_renderGlobals->imagePath + "/" + this->mtlu_renderGlobals->imageName + "." + (int)this->mtlu_renderGlobals->currentFrame;
const char *filename = fileName.asChar();
const int xres = width;
const int yres = height;
const bool write_png = true;
const int halttime = this->mtlu_renderGlobals->halttime;
const int haltspp = this->mtlu_renderGlobals->haltspp;
int displayinterval = 3;
ParamSet fp = CreateParamSet();
fp->AddInt("xresolution",&xres);
fp->AddInt("yresolution",&yres);
fp->AddBool("write_png",&write_png);
fp->AddString("filename",&filename);
if( halttime > 0)
fp->AddInt("halttime", &halttime);
if( haltspp > 0)
fp->AddInt("haltspp", &haltspp);
if( displayinterval > 0)
fp->AddInt("displayinterval", &displayinterval);
lux->film("fleximage", boost::get_pointer(fp));
}
int main(int argc, char* argv[]) {
UIDSet uids;
if (argc < 3) {
std::cerr << "ERROR: Must have at least two arguments: basename and a UID"
<< std::endl;
return -1;
}
try {
stoi(argv[1], NULL, 10);
std::cerr << "ERROR: First argument must not be an integer"
<< std::endl;
return -1;
} catch (...) {}
std::string basename(std::string(argv[1]) + "_mixed");
if (basename.find("/") != std::string::npos) {
std::cerr << "ERROR: Basename may not contain path separator"
<< std::endl;
return -1;
}
for (int i = 2; i < argc; ++i) {
uids.insert(stoi(argv[i], NULL, 10));
}
ParamSet extraParams;
extraParams.insert(-1); // Don't-care value
SetuidState startState = SetuidState::get();
Explorer explorer(
Graph(VG(), uids, startState),
EG(),
uids,
extraParams);
explorer.exploreAll();
Graph const& graph = explorer.getGraph();
GraphName name(basename, uids, extraParams);
ArchiveWriter<Graph>().write(graph, name);
DotWriter<Graph>().write(graph, name);
return 0;
}
void Heightfield::Refine(vector<Reference<Shape> > &refined) const {
int ntris = 2*(nx-1)*(ny-1);
refined.reserve(ntris);
int *verts = new int[3*ntris];
Point *P = new Point[nx*ny];
float *uvs = new float[2*nx*ny];
int nverts = nx*ny;
int x, y;
// Compute heightfield vertex positions
int pos = 0;
for (y = 0; y < ny; ++y) {
for (x = 0; x < nx; ++x) {
P[pos].x = uvs[2*pos] = (float)x / (float)(nx-1);
P[pos].y = uvs[2*pos+1] = (float)y / (float)(ny-1);
P[pos].z = z[pos];
++pos;
}
}
// Fill in heightfield vertex offset array
int *vp = verts;
for (y = 0; y < ny-1; ++y) {
for (x = 0; x < nx-1; ++x) {
#define VERT(x,y) ((x)+(y)*nx)
*vp++ = VERT(x, y);
*vp++ = VERT(x+1, y);
*vp++ = VERT(x+1, y+1);
*vp++ = VERT(x, y);
*vp++ = VERT(x+1, y+1);
*vp++ = VERT(x, y+1);
}
#undef VERT
}
ParamSet paramSet;
paramSet.AddInt("indices", verts, 3*ntris);
paramSet.AddFloat("uv", uvs, 2 * nverts);
paramSet.AddPoint("P", P, nverts);
refined.push_back(CreateTriangleMeshShape(ObjectToWorld, WorldToObject, ReverseOrientation, paramSet));
delete[] P;
delete[] uvs;
delete[] verts;
}
void SceneCache::initDefault() {
Color errorColor = Color::Magenta;
ColorTexturePtr errorCTexture(new ConstantTexture<Color>(errorColor));
addColorTexture(mErrorCode, errorCTexture);
FloatTexturePtr errorFTexture(new ConstantTexture<float>(0.5f));
addFloatTexture(mErrorCode, errorFTexture);
MaterialPtr errorMaterial(new LambertMaterial(errorCTexture));
addMaterial(mErrorCode, errorMaterial);
Geometry* errorGeometry = new Sphere(1.0f);
errorGeometry->init();
addGeometry(mErrorCode, errorGeometry);
ParamSet modelParams;
modelParams.setString("geometry", mErrorCode);
modelParams.setString("material", mErrorCode);
const Primitive* errorPrimitive =
ModelPrimitiveCreator().create(modelParams, *this);
addPrimitive(mErrorCode, errorPrimitive);
addAreaLight(mErrorCode, NULL);
}
std::shared_ptr<Medium> MakeMedium(const std::string &name,
const ParamSet ¶mSet,
const Transform &medium2world) {
Float sig_a_rgb[3] = {.0011f, .0024f, .014f},
sig_s_rgb[3] = {2.55f, 3.21f, 3.77f};
Spectrum sig_a = Spectrum::FromRGB(sig_a_rgb),
sig_s = Spectrum::FromRGB(sig_s_rgb);
std::string preset = paramSet.FindOneString("preset", "");
bool found = GetMediumScatteringProperties(preset, &sig_a, &sig_s);
if (preset != "" && !found)
Warning("Material preset \"%s\" not found. Using defaults.",
preset.c_str());
Float scale = paramSet.FindOneFloat("scale", 1.f);
Float g = paramSet.FindOneFloat("g", 0.0f);
sig_a = paramSet.FindOneSpectrum("sigma_a", sig_a) * scale;
sig_s = paramSet.FindOneSpectrum("sigma_s", sig_s) * scale;
Medium *m = NULL;
if (name == "homogeneous") {
m = new HomogeneousMedium(sig_a, sig_s, g);
} else if (name == "heterogeneous") {
int nitems;
const Float *data = paramSet.FindFloat("density", &nitems);
if (!data) {
Error("No \"density\" values provided for heterogeneous medium?");
return NULL;
}
int nx = paramSet.FindOneInt("nx", 1);
int ny = paramSet.FindOneInt("ny", 1);
int nz = paramSet.FindOneInt("nz", 1);
Point3f p0 = paramSet.FindOnePoint3f("p0", Point3f(0.f, 0.f, 0.f));
Point3f p1 = paramSet.FindOnePoint3f("p1", Point3f(1.f, 1.f, 1.f));
if (nitems != nx * ny * nz) {
Error(
"GridDensityMedium has %d density values; expected nx*ny*nz = "
"%d",
nitems, nx * ny * nz);
return NULL;
}
Transform data2Medium = Translate(Vector3f(p0)) *
Scale(p1.x - p0.x, p1.y - p0.y, p1.z - p0.z);
m = new GridDensityMedium(sig_a, sig_s, g, nx, ny, nz,
medium2world * data2Medium, data);
} else
Warning("Medium \"%s\" unknown.", name.c_str());
paramSet.ReportUnused();
return std::shared_ptr<Medium>(m);
}
QVariant AlertSubscriptionData::uiData(int section, int role) const {
switch(role) {
case Qt::DisplayRole:
case Qt::EditRole:
switch(section) {
case 0:
return _id;
case 1:
return _pattern;
case 2:
return _channelName;
case 3:
return _address;
case 4: {
QString s;
if (!_emitMessage.isEmpty())
s.append(" emitmessage=").append(_emitMessage);
if (!_cancelMessage.isEmpty())
s.append(" cancelmessage=").append(_cancelMessage);
if (!_reminderMessage.isEmpty())
s.append(" remindermessage=").append(_reminderMessage);
return s.mid(1);
}
case 5: {
QString s;
if (!_notifyEmit)
s.append(" noemitnotify");
if (!_notifyCancel)
s.append(" nocancelnotify");
if (!_notifyReminder)
s.append(" noremindernotify");
return s.mid(1);
}
case 6:
return _emitMessage;
case 7:
return _cancelMessage;
case 8:
return _reminderMessage;
case 9:
return _notifyEmit;
case 10:
return _notifyCancel;
case 11:
return _notifyReminder;
case 12:
return _params.toString(false, false);
}
break;
default:
;
}
return QVariant();
}
// Object Creation Function Definitions
std::vector<std::shared_ptr<Shape>> MakeShapes(const std::string &name,
const Transform *object2world,
const Transform *world2object,
bool reverseOrientation,
const ParamSet ¶mSet) {
std::vector<std::shared_ptr<Shape>> shapes;
std::shared_ptr<Shape> s;
if (name == "sphere")
s = CreateSphereShape(object2world, world2object, reverseOrientation,
paramSet);
// Create remaining single _Shape_ types
else if (name == "cylinder")
s = CreateCylinderShape(object2world, world2object, reverseOrientation,
paramSet);
else if (name == "disk")
s = CreateDiskShape(object2world, world2object, reverseOrientation,
paramSet);
else if (name == "cone")
s = CreateConeShape(object2world, world2object, reverseOrientation,
paramSet);
else if (name == "paraboloid")
s = CreateParaboloidShape(object2world, world2object,
reverseOrientation, paramSet);
else if (name == "hyperboloid")
s = CreateHyperboloidShape(object2world, world2object,
reverseOrientation, paramSet);
if (s != nullptr) shapes.push_back(s);
// Create multiple-_Shape_ types
else if (name == "curve")
shapes = CreateCurveShape(object2world, world2object,
reverseOrientation, paramSet);
else if (name == "trianglemesh")
shapes = CreateTriangleMeshShape(object2world, world2object,
reverseOrientation, paramSet,
&graphicsState.floatTextures);
else if (name == "plymesh")
shapes = CreatePLYMesh(object2world, world2object, reverseOrientation,
paramSet, &graphicsState.floatTextures);
else if (name == "heightfield")
shapes = CreateHeightfield(object2world, world2object,
reverseOrientation, paramSet);
else if (name == "loopsubdiv")
shapes = CreateLoopSubdiv(object2world, world2object,
reverseOrientation, paramSet);
else if (name == "nurbs")
shapes = CreateNURBS(object2world, world2object, reverseOrientation,
paramSet);
else
Warning("Shape \"%s\" unknown.", name.c_str());
paramSet.ReportUnused();
return shapes;
}
std::shared_ptr<BVHAccel> CreateBVHAccelerator(
const std::vector<std::shared_ptr<Primitive>> &prims, const ParamSet &ps) {
std::string splitMethodName = ps.FindOneString("splitmethod", "sah");
BVHAccel::SplitMethod splitMethod;
if (splitMethodName == "sah")
splitMethod = BVHAccel::SplitMethod::SAH;
else if (splitMethodName == "hlbvh")
splitMethod = BVHAccel::SplitMethod::HLBVH;
else if (splitMethodName == "middle")
splitMethod = BVHAccel::SplitMethod::Middle;
else if (splitMethodName == "equal")
splitMethod = BVHAccel::SplitMethod::EqualCounts;
else {
Warning("BVH split method \"%s\" unknown. Using \"sah\".",
splitMethodName.c_str());
splitMethod = BVHAccel::SplitMethod::SAH;
}
int maxPrimsInNode = ps.FindOneInt("maxnodeprims", 4);
return std::make_shared<BVHAccel>(prims, maxPrimsInNode, splitMethod);
}
std::shared_ptr<AreaLight> MakeAreaLight(const std::string &name,
const Transform &light2world,
const MediumInterface &mediumInterface,
const ParamSet ¶mSet,
const std::shared_ptr<Shape> &shape) {
std::shared_ptr<AreaLight> area;
if (name == "area" || name == "diffuse")
area = CreateDiffuseAreaLight(light2world, mediumInterface.outside,
paramSet, shape);
else
Warning("Area light \"%s\" unknown.", name.c_str());
paramSet.ReportUnused();
return area;
}
std::shared_ptr<Primitive> MakeAccelerator(
const std::string &name,
const std::vector<std::shared_ptr<Primitive>> &prims,
const ParamSet ¶mSet) {
std::shared_ptr<Primitive> accel;
if (name == "bvh")
accel = CreateBVHAccelerator(prims, paramSet);
else if (name == "kdtree")
accel = CreateKdTreeAccelerator(prims, paramSet);
else
Warning("Accelerator \"%s\" unknown.", name.c_str());
paramSet.ReportUnused();
return accel;
}
std::vector<std::shared_ptr<Shape>> CreateCurveShape(const Transform *o2w,
const Transform *w2o,
bool reverseOrientation,
const ParamSet ¶ms) {
Float width = params.FindOneFloat("width", 1.f);
Float width0 = params.FindOneFloat("width0", width);
Float width1 = params.FindOneFloat("width1", width);
int ncp;
const Point3f *cp = params.FindPoint3f("P", &ncp);
if (ncp != 4) {
Error(
"Must provide 4 control points for \"curve\" primitive. "
"(Provided %d).",
ncp);
return std::vector<std::shared_ptr<Shape>>();
}
CurveType type;
std::string curveType = params.FindOneString("type", "flat");
if (curveType == "flat")
type = CurveType::Flat;
else if (curveType == "ribbon")
type = CurveType::Ribbon;
else if (curveType == "cylinder")
type = CurveType::Cylinder;
else {
Error("Unknown curve type \"%s\". Using \"flat\".", curveType.c_str());
type = CurveType::Cylinder;
}
int nnorm;
const Normal3f *n = params.FindNormal3f("N", &nnorm);
if (n != nullptr) {
if (type != CurveType::Ribbon) {
Warning("Curve normals are only used with \"ribbon\" type curves.");
n = nullptr;
} else if (nnorm != 2) {
Error(
"Must provide two normals with \"N\" parameter for ribbon "
"curves. "
"(Provided %d).",
nnorm);
return std::vector<std::shared_ptr<Shape>>();
}
}
int sd = params.FindOneFloat("splitdepth", 2);
if (type == CurveType::Ribbon && n == nullptr) {
Error(
"Must provide normals \"N\" at curve endpoints with ribbon "
"curves.");
return std::vector<std::shared_ptr<Shape>>();
} else
return CreateCurve(o2w, w2o, reverseOrientation, cp, width0, width1,
type, n, sd);
}
GraphName::GraphName(
std::string const& basename,
UIDSet const& uidSet,
ParamSet const& paramSet) {
std::vector<int> uids, params;
for (UIDSet::const_iterator it = uidSet.begin(), ie = uidSet.end();
it != ie; ++it) {
uids.push_back(static_cast<int>(*it));
}
std::sort(uids.begin(), uids.end());
for (ParamSet::const_iterator it = paramSet.begin(), ie = paramSet.end();
it != ie; ++it) {
params.push_back(*it);
}
std::sort(params.begin(), params.end());
std::stringstream ss;
ss << basename << "__u_";
for (std::vector<int>::iterator it = uids.begin(), ie = uids.end();
it != ie; ++it) {
ss << *it;
if (it +1 != uids.end()) {
ss << "_";
}
}
ss << "__p_";
for (std::vector<int>::iterator it = params.begin(), ie = params.end();
it != ie; ++it) {
ss << *it;
if (it +1 != params.end()) {
ss << "_";
}
}
name = ss.str();
}