// ----------------------------------------------------------------------------- // ----------------------------------------------------------------------------- M113a_Chassis::M113a_Chassis(const std::string& name, bool fixed, ChassisCollisionType chassis_collision_type) : ChRigidChassis(name, fixed) { m_inertia.SetElement(0, 0, m_inertiaXX.x()); m_inertia.SetElement(1, 1, m_inertiaXX.y()); m_inertia.SetElement(2, 2, m_inertiaXX.z()); m_inertia.SetElement(0, 1, m_inertiaXY.x()); m_inertia.SetElement(0, 2, m_inertiaXY.y()); m_inertia.SetElement(1, 2, m_inertiaXY.z()); m_inertia.SetElement(1, 0, m_inertiaXY.x()); m_inertia.SetElement(2, 0, m_inertiaXY.y()); m_inertia.SetElement(2, 1, m_inertiaXY.z()); // Belly shape (all dimensions in cm) // width: 170 // points in x-z transversal plane: (-417.0 -14.3), (4.1, -14.3), (21.4, 34.3) // thickness: 20 double width = 1.70; double Ax = -4.17; double Az = -0.143; double Bx = 0.041; double Bz = -0.143; double Cx = 0.214; double Cz = 0.343; double thickness = 0.2; ChVector<> dims1((Bx - Ax), width, thickness); ChVector<> loc1(0.5 * (Ax + Bx), 0.0, Az + 0.5 * thickness); ChQuaternion<> rot1(1, 0, 0, 0); BoxShape box1(loc1, rot1, dims1); double alpha = std::atan2(Cz - Bz, Cx - Bx); // pitch angle of front box ChVector<> dims2((Cx - Bx) / std::cos(alpha), width, thickness); ChVector<> loc2(0.5 * (Bx + Cx) - 0.5 * thickness * std::sin(alpha), 0.0, 0.5 * (Bz + Cz) + 0.5 * thickness * std::cos(alpha)); ChQuaternion<> rot2 = Q_from_AngY(-alpha); BoxShape box2(loc2, rot2, dims2); m_has_primitives = true; m_vis_boxes.push_back(box1); m_vis_boxes.push_back(box2); m_has_mesh = true; m_vis_mesh_name = "Chassis_POV_geom"; m_vis_mesh_file = "M113/Chassis.obj"; m_has_collision = (chassis_collision_type != ChassisCollisionType::NONE); switch (chassis_collision_type) { case ChassisCollisionType::PRIMITIVES: m_coll_boxes.push_back(box1); m_coll_boxes.push_back(box2); break; case ChassisCollisionType::MESH: m_coll_mesh_names.push_back("M113/Chassis_Hulls.obj"); break; default: break; } }
// Compute the mapping between linear array and the hypercube // corresponding to all the trees. void GeneratorTrees::ComputeCubeMapping() { assert(trees.length()>=1); if (trees.length()==1) { // A single tree ComputeOneGenMapping(map2array, trees[0]); } else { // more than one generator // Compute the sub-mapping for every generator. Also prepare two hypercube // signature objects for the index calculations, with the two ordering of // the generators: one for the generators ordered by their index 0,1,2... // and the other odred the generators by the order of their trees Vec<long> dims1(INIT_SIZE,trees.length()), dims2(INIT_SIZE,trees.length()); Vec<Permut> genMappings(INIT_SIZE, trees.length()); for (long i=0; i<trees.length(); i++) { dims1[i] = trees[i][0].getData().size; ComputeOneGenMapping(genMappings[i], trees[i]); } getCubeDims(dims2); CubeSignature sig1(dims1), sig2(dims2); // Allocate space for the mapping map2array.SetLength(sig1.getSize()); // Combine the generator perms to a single permutation over the cube for (long i=0; i<map2array.length(); i++) { long t=0; for (long j1=0; j1<trees.length(); j1++) { long j2 = trees[j1].getAuxKey(); long digit = sig1.getCoord(i,j1); // the j1 digit of i in base dims digit = genMappings[j1][digit]; // apply the j1 permutation to it t += digit * sig2.getProd(j2+1); // adds the permuted digit } map2array[i] = t; } } // Compute the inverse permutation map2cube.SetLength(map2array.length()); for (long i=0; i<map2array.length(); i++) map2cube[ map2array[i] ] = i; }
int main(int argc, char** argv) { try { // Parse the command line if (argc != 2) { std::cerr << "Usage: " << sys::Path::basename(argv[0]) << " <output NITF pathname prefix>\n\n"; return 1; } const std::string outPathnamePrefix(argv[1]); verifySchemaEnvVariableIsSet(); // In order to make it easier to test segmenting, let's artificially set // the segment size really small const size_t numCols = 200; const size_t maxSize = numCols * 50; six::XMLControlRegistry xmlRegistry; xmlRegistry.addCreator( six::DataType::DERIVED, new six::XMLControlCreatorT< six::sidd::DerivedXMLControl>()); six::Container container(six::DataType::DERIVED); std::vector<six::UByte*> buffers; // First a single segment without a legend types::RowCol<size_t> dims1(40, numCols); std::auto_ptr<six::Data> data1(mockupDerivedData(dims1)); const mem::ScopedArray<sys::ubyte> buffer1(new sys::ubyte[dims1.normL1()]); std::fill_n(buffer1.get(), dims1.normL1(), 20); container.addData(data1); buffers.push_back(buffer1.get()); // Now a single segment with a mono legend types::RowCol<size_t> dims2(40, numCols); std::auto_ptr<six::Data> data2(mockupDerivedData(dims2)); const types::RowCol<size_t> legendDims(50, 50); std::auto_ptr<six::Legend> monoLegend(new six::Legend()); monoLegend->mType = six::PixelType::MONO8I; monoLegend->mLocation.row = 10; monoLegend->mLocation.col = 10; monoLegend->setDims(legendDims); const mem::ScopedArray<sys::ubyte> buffer2(new sys::ubyte[dims2.normL1()]); std::fill_n(buffer2.get(), dims2.normL1(), 100); container.addData(data2, monoLegend); buffers.push_back(buffer2.get()); // Now a multi-segment without a legend types::RowCol<size_t> dims3(150, numCols); std::auto_ptr<six::Data> data3(mockupDerivedData(dims3)); const mem::ScopedArray<sys::ubyte> buffer3(new sys::ubyte[dims3.normL1()]); std::fill_n(buffer3.get(), dims3.normL1(), 60); container.addData(data3); buffers.push_back(buffer3.get()); // Now a multi-segment with an RGB legend types::RowCol<size_t> dims4(155, numCols); std::auto_ptr<six::Data> data4(mockupDerivedData(dims4)); std::auto_ptr<six::Legend> rgbLegend(new six::Legend()); rgbLegend->mType = six::PixelType::RGB8LU; rgbLegend->mLocation.row = 10; rgbLegend->mLocation.col = 10; rgbLegend->setDims(legendDims); rgbLegend->mLUT.reset(new six::LUT(256, 3)); for (size_t ii = 0, idx = 0; ii < rgbLegend->mLUT->numEntries; ++ii, idx += 3) { rgbLegend->mLUT->table[idx] = ii; rgbLegend->mLUT->table[idx + 1] = ii; rgbLegend->mLUT->table[idx + 2] = ii; } const mem::ScopedArray<sys::ubyte> buffer4(new sys::ubyte[dims4.normL1()]); std::fill_n(buffer4.get(), dims4.normL1(), 200); container.addData(data4, rgbLegend); buffers.push_back(buffer4.get()); // Write it out { six::NITFWriteControl writer; writer.getOptions().setParameter( six::NITFWriteControl::OPT_MAX_PRODUCT_SIZE, str::toString(maxSize)); writer.setXMLControlRegistry(&xmlRegistry); writer.initialize(&container); writer.save(buffers, outPathnamePrefix + "_unblocked.nitf"); } // Write it out with blocking { six::NITFWriteControl writer; writer.getOptions().setParameter( six::NITFWriteControl::OPT_MAX_PRODUCT_SIZE, str::toString(maxSize)); const std::string blockSize("1024"); writer.getOptions().setParameter( six::NITFWriteControl::OPT_NUM_ROWS_PER_BLOCK, blockSize); writer.getOptions().setParameter( six::NITFWriteControl::OPT_NUM_COLS_PER_BLOCK, blockSize); writer.setXMLControlRegistry(&xmlRegistry); writer.initialize(&container); writer.save(buffers, outPathnamePrefix + "_blocked.nitf"); } return 0; } catch (const except::Exception& e) { std::cerr << "Caught exception: " << e.getMessage() << std::endl; return 1; } catch (const std::exception& e) { std::cerr << "Caught exception: " << e.what() << std::endl; return 1; } catch (...) { std::cerr << "Unknown exception\n"; return 1; } }