int main(int argc, char* argv[])
{
osmscout::ImportParameter parameter;
osmscout::ConsoleProgress progress;
bool parameterError=false;
std::string mapfile=parameter.GetMapfile();
std::string typefile=parameter.GetTypefile();
std::string destinationDirectory=parameter.GetDestinationDirectory();
size_t startStep=parameter.GetStartStep();
size_t endStep=parameter.GetEndStep();
bool strictAreas=parameter.GetStrictAreas();
size_t numericIndexPageSize=parameter.GetNumericIndexPageSize();
size_t sortBlockSize=parameter.GetSortBlockSize();
bool coordDataMemoryMaped=parameter.GetCoordDataMemoryMaped();
bool rawNodeDataMemoryMaped=parameter.GetRawNodeDataMemoryMaped();
size_t rawNodeDataCacheSize=parameter.GetRawNodeDataCacheSize();
bool rawWayIndexMemoryMaped=parameter.GetRawWayIndexMemoryMaped();
bool rawWayDataMemoryMaped=parameter.GetRawWayDataMemoryMaped();
size_t rawWayDataCacheSize=parameter.GetRawWayDataCacheSize();
size_t rawWayIndexCacheSize=parameter.GetRawWayIndexCacheSize();
size_t rawWayBlockSize=parameter.GetRawWayBlockSize();
bool areaDataMemoryMaped=parameter.GetAreaDataMemoryMaped();
size_t areaDataCacheSize=parameter.GetAreaDataCacheSize();
bool wayDataMemoryMaped=parameter.GetWayDataMemoryMaped();
size_t wayDataCacheSize=parameter.GetWayDataCacheSize();
size_t routeNodeBlockSize=parameter.GetRouteNodeBlockSize();
// Simple way to analyse command line parameters, but enough for now...
int i=1;
while (i<argc) {
if (strcmp(argv[i],"-s")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
startStep);
}
else if (strcmp(argv[i],"-e")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
endStep);
}
else if (strcmp(argv[i],"-d")==0) {
progress.SetOutputDebug(true);
i++;
}
else if (strcmp(argv[i],"-h")==0) {
DumpHelp(parameter);
return 0;
}
else if (strcmp(argv[i],"--help")==0) {
DumpHelp(parameter);
return 0;
}
else if (strcmp(argv[i],"--typefile")==0) {
parameterError=!ParseStringArgument(argc,
argv,
i,
typefile);
}
else if (strcmp(argv[i],"--destinationDirectory")==0) {
parameterError=!ParseStringArgument(argc,
argv,
i,
destinationDirectory);
}
else if (strcmp(argv[i],"--strictAreas")==0) {
parameterError=!ParseBoolArgument(argc,
argv,
i,
strictAreas);
}
else if (strcmp(argv[i],"--numericIndexPageSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
numericIndexPageSize);
}
else if (strcmp(argv[i],"--coordDataMemoryMaped")==0) {
parameterError=!ParseBoolArgument(argc,
argv,
i,
coordDataMemoryMaped);
}
else if (strcmp(argv[i],"--rawNodeDataMemoryMaped")==0) {
parameterError=!ParseBoolArgument(argc,
argv,
i,
rawNodeDataMemoryMaped);
}
else if (strcmp(argv[i],"--rawNodeDataCacheSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
rawNodeDataCacheSize);
}
else if (strcmp(argv[i],"--rawWayIndexMemoryMaped")==0) {
parameterError=!ParseBoolArgument(argc,
argv,
i,
rawWayIndexMemoryMaped);
}
else if (strcmp(argv[i],"--rawWayDataMemoryMaped")==0) {
parameterError=!ParseBoolArgument(argc,
argv,
i,
rawWayDataMemoryMaped);
}
else if (strcmp(argv[i],"--rawWayDataCacheSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
rawWayDataCacheSize);
}
else if (strcmp(argv[i],"--rawWayIndexCacheSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
rawWayIndexCacheSize);
}
else if (strcmp(argv[i],"--rawWayBlockSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
rawWayBlockSize);
}
else if (strcmp(argv[i],"-noSort")==0) {
parameter.SetSortObjects(false);
i++;
}
else if (strcmp(argv[i],"--sortBlockSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
sortBlockSize);
}
else if (strcmp(argv[i],"--areaDataMemoryMaped")==0) {
parameterError=!ParseBoolArgument(argc,
argv,
i,
areaDataMemoryMaped);
}
else if (strcmp(argv[i],"--areaDataCacheSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
areaDataCacheSize);
}
else if (strcmp(argv[i],"--wayDataMemoryMaped")==0) {
parameterError=!ParseBoolArgument(argc,
argv,
i,
wayDataMemoryMaped);
}
else if (strcmp(argv[i],"--wayDataCacheSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
wayDataCacheSize);
}
else if (strcmp(argv[i],"--routeNodeBlockSize")==0) {
parameterError=!ParseSizeTArgument(argc,
argv,
i,
routeNodeBlockSize);
}
else if (mapfile.empty()) {
mapfile=argv[i];
i++;
}
else {
std::cerr << "Unknown option: " << argv[i] << std::endl;
parameterError=true;
i++;
}
}
if (startStep==1 &&
mapfile.empty()) {
parameterError=true;
}
if (parameterError) {
DumpHelp(parameter);
return 1;
}
parameter.SetMapfile(mapfile);
parameter.SetTypefile(typefile);
parameter.SetDestinationDirectory(destinationDirectory);
parameter.SetSteps(startStep,endStep);
parameter.SetStrictAreas(strictAreas);
parameter.SetNumericIndexPageSize(numericIndexPageSize);
parameter.SetSortBlockSize(sortBlockSize);
parameter.SetCoordDataMemoryMaped(coordDataMemoryMaped);
parameter.SetRawNodeDataMemoryMaped(rawNodeDataMemoryMaped);
parameter.SetRawNodeDataCacheSize(rawNodeDataCacheSize);
parameter.SetRawWayIndexMemoryMaped(rawWayIndexMemoryMaped);
parameter.SetRawWayDataMemoryMaped(rawWayDataMemoryMaped);
parameter.SetRawWayDataCacheSize(rawWayDataCacheSize);
parameter.SetRawWayIndexCacheSize(rawWayIndexCacheSize);
parameter.SetRawWayBlockSize(rawWayBlockSize);
parameter.SetAreaDataMemoryMaped(areaDataMemoryMaped);
parameter.SetAreaDataCacheSize(areaDataCacheSize);
parameter.SetWayDataMemoryMaped(wayDataMemoryMaped);
parameter.SetWayDataCacheSize(wayDataCacheSize);
parameter.SetRouteNodeBlockSize(routeNodeBlockSize);
parameter.SetOptimizationWayMethod(osmscout::TransPolygon::quality);
progress.SetStep("Dump parameter");
progress.Info(std::string("Mapfile: ")+parameter.GetMapfile());
progress.Info(std::string("typefile: ")+parameter.GetTypefile());
progress.Info(std::string("Destination directory: ")+parameter.GetDestinationDirectory());
progress.Info(std::string("Steps: ")+
osmscout::NumberToString(parameter.GetStartStep())+
" - "+
osmscout::NumberToString(parameter.GetEndStep()));
progress.Info(std::string("StrictAreas: ")+
(parameter.GetStrictAreas() ? "true" : "false"));
progress.Info(std::string("NumericIndexPageSize: ")+
osmscout::NumberToString(parameter.GetNumericIndexPageSize()));
progress.Info(std::string("CoordDataMemoryMaped: ")+
(parameter.GetCoordDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("RawNodeDataMemoryMaped: ")+
(parameter.GetRawNodeDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("RawNodeDataCacheSize: ")+
osmscout::NumberToString(parameter.GetRawNodeDataCacheSize()));
progress.Info(std::string("RawWayIndexMemoryMaped: ")+
(parameter.GetRawWayIndexMemoryMaped() ? "true" : "false"));
progress.Info(std::string("RawWayDataMemoryMaped: ")+
(parameter.GetRawWayDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("RawWayDataCacheSize: ")+
osmscout::NumberToString(parameter.GetRawWayDataCacheSize()));
progress.Info(std::string("RawWayIndexCacheSize: ")+
osmscout::NumberToString(parameter.GetRawWayIndexCacheSize()));
progress.Info(std::string("RawWayBlockSize: ")+
osmscout::NumberToString(parameter.GetRawWayBlockSize()));
progress.Info(std::string("SortObjects: ")+
(parameter.GetSortObjects() ? "true" : "false"));
progress.Info(std::string("SortBlockSize: ")+
osmscout::NumberToString(parameter.GetSortBlockSize()));
progress.Info(std::string("AreaDataMemoryMaped: ")+
(parameter.GetAreaDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("AreaDataCacheSize: ")+
osmscout::NumberToString(parameter.GetAreaDataCacheSize()));
progress.Info(std::string("WayDataMemoryMaped: ")+
(parameter.GetWayDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("WayDataCacheSize: ")+
osmscout::NumberToString(parameter.GetWayDataCacheSize()));
progress.Info(std::string("RouteNodeBlockSize: ")+
osmscout::NumberToString(parameter.GetRouteNodeBlockSize()));
if (osmscout::Import(parameter,progress)) {
std::cout << "Import OK!" << std::endl;
}
else {
std::cerr << "Import failed!" << std::endl;
}
return 0;
}
int main(int argc, char* argv[])
{
osmscout::ImportParameter parameter;
osmscout::ConsoleProgress progress;
bool parameterError=false;
bool firstRouterOption=true;
std::list<std::string> mapfiles;
osmscout::VehicleMask defaultVehicleMask=osmscout::vehicleBicycle|osmscout::vehicleFoot|osmscout::vehicleCar;
parameter.AddRouter(osmscout::ImportParameter::Router(defaultVehicleMask,
"router"));
// Simple way to analyze command line parameters, but enough for now...
int i=1;
while (i<argc) {
if (strcmp(argv[i],"-h")==0 ||
strcmp(argv[i],"-?")==0 ||
strcmp(argv[i],"--help")==0) {
DumpHelp(parameter);
return 0;
}
else if (strcmp(argv[i],"-s")==0) {
size_t startStep;
if (ParseSizeTArgument(argc,
argv,
i,
startStep)) {
parameter.SetSteps(startStep,
parameter.GetEndStep());
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"-e")==0) {
size_t endStep;
if (ParseSizeTArgument(argc,
argv,
i,
endStep)) {
parameter.SetSteps(parameter.GetStartStep(),
endStep);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"-d")==0) {
progress.SetOutputDebug(true);
i++;
}
else if (strcmp(argv[i],"--typefile")==0) {
std::string typefile;
if (ParseStringArgument(argc,
argv,
i,
typefile)) {
parameter.SetTypefile(typefile);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--destinationDirectory")==0) {
std::string destinationDirectory;
if (ParseStringArgument(argc,
argv,
i,
destinationDirectory)) {
parameter.SetDestinationDirectory(destinationDirectory);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--router")==0) {
if (firstRouterOption) {
parameter.ClearRouter();
firstRouterOption=false;
}
osmscout::ImportParameter::RouterRef router=ParseRouterArgument(argc,
argv,
i);
if (router) {
parameter.AddRouter(*router);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--strictAreas")==0) {
bool strictAreas;
if (ParseBoolArgument(argc,
argv,
i,
strictAreas)) {
parameter.SetStrictAreas(strictAreas);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--numericIndexPageSize")==0) {
size_t numericIndexPageSize;
if (ParseSizeTArgument(argc,
argv,
i,
numericIndexPageSize)) {
parameter.SetNumericIndexPageSize(numericIndexPageSize);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--coordDataMemoryMaped")==0) {
bool coordDataMemoryMaped;
if (ParseBoolArgument(argc,
argv,
i,
coordDataMemoryMaped)) {
parameter.SetCoordDataMemoryMaped(coordDataMemoryMaped);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--rawNodeDataMemoryMaped")==0) {
bool rawNodeDataMemoryMaped;
if (ParseBoolArgument(argc,
argv,
i,
rawNodeDataMemoryMaped)) {
parameter.SetRawNodeDataMemoryMaped(rawNodeDataMemoryMaped);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--rawWayIndexMemoryMaped")==0) {
bool rawWayIndexMemoryMaped;
if (ParseBoolArgument(argc,
argv,
i,
rawWayIndexMemoryMaped)) {
parameter.SetRawWayIndexMemoryMaped(rawWayIndexMemoryMaped);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--rawWayDataMemoryMaped")==0) {
bool rawWayDataMemoryMaped;
if (ParseBoolArgument(argc,
argv,
i,
rawWayDataMemoryMaped)) {
parameter.SetRawWayDataMemoryMaped(rawWayDataMemoryMaped);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--rawWayIndexCacheSize")==0) {
size_t rawWayIndexCacheSize;
if (ParseSizeTArgument(argc,
argv,
i,
rawWayIndexCacheSize)) {
parameter.SetRawWayIndexCacheSize(rawWayIndexCacheSize);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--rawWayBlockSize")==0) {
size_t rawWayBlockSize;
if (ParseSizeTArgument(argc,
argv,
i,
rawWayBlockSize)) {
parameter.SetRawWayBlockSize(rawWayBlockSize);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"-noSort")==0) {
parameter.SetSortObjects(false);
i++;
}
else if (strcmp(argv[i],"--sortBlockSize")==0) {
size_t sortBlockSize;
if (ParseSizeTArgument(argc,
argv,
i,
sortBlockSize)) {
parameter.SetSortBlockSize(sortBlockSize);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--areaDataMemoryMaped")==0) {
bool areaDataMemoryMaped;
if (ParseBoolArgument(argc,
argv,
i,
areaDataMemoryMaped)) {
parameter.SetAreaDataMemoryMaped(areaDataMemoryMaped);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--areaDataCacheSize")==0) {
size_t areaDataCacheSize;
if (ParseSizeTArgument(argc,
argv,
i,
areaDataCacheSize)) {
parameter.SetAreaDataCacheSize(areaDataCacheSize);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--wayDataMemoryMaped")==0) {
bool wayDataMemoryMaped;
if (ParseBoolArgument(argc,
argv,
i,
wayDataMemoryMaped)) {
parameter.SetWayDataMemoryMaped(wayDataMemoryMaped);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--wayDataCacheSize")==0) {
size_t wayDataCacheSize;
if (ParseSizeTArgument(argc,
argv,
i,
wayDataCacheSize)) {
parameter.SetWayDataCacheSize(wayDataCacheSize);
}
else {
parameterError=true;
}
}
else if (strcmp(argv[i],"--routeNodeBlockSize")==0) {
size_t routeNodeBlockSize;
if (ParseSizeTArgument(argc,
argv,
i,
routeNodeBlockSize)) {
parameter.SetRouteNodeBlockSize(routeNodeBlockSize);
}
else {
parameterError=true;
}
}
else if (strncmp(argv[i],"--",2)==0) {
std::cerr << "Unknown option: " << argv[i] << std::endl;
parameterError=true;
i++;
}
else {
mapfiles.push_back(argv[i]);
i++;
}
}
if (parameter.GetStartStep()==1 &&
mapfiles.empty()) {
parameterError=true;
}
if (parameterError) {
DumpHelp(parameter);
return 1;
}
parameter.SetMapfiles(mapfiles);
parameter.SetOptimizationWayMethod(osmscout::TransPolygon::quality);
progress.SetStep("Dump parameter");
for (const auto& filename : parameter.GetMapfiles()) {
progress.Info(std::string("Mapfile: ")+filename);
}
progress.Info(std::string("typefile: ")+parameter.GetTypefile());
progress.Info(std::string("Destination directory: ")+parameter.GetDestinationDirectory());
progress.Info(std::string("Steps: ")+
osmscout::NumberToString(parameter.GetStartStep())+
" - "+
osmscout::NumberToString(parameter.GetEndStep()));
for (const auto& router : parameter.GetRouter()) {
progress.Info(std::string("Router: ")+VehcileMaskToString(router.GetVehicleMask())+ " - '"+router.GetFilenamebase()+"'");
}
progress.Info(std::string("StrictAreas: ")+
(parameter.GetStrictAreas() ? "true" : "false"));
progress.Info(std::string("NumericIndexPageSize: ")+
osmscout::NumberToString(parameter.GetNumericIndexPageSize()));
progress.Info(std::string("CoordDataMemoryMaped: ")+
(parameter.GetCoordDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("RawNodeDataMemoryMaped: ")+
(parameter.GetRawNodeDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("RawWayIndexMemoryMaped: ")+
(parameter.GetRawWayIndexMemoryMaped() ? "true" : "false"));
progress.Info(std::string("RawWayDataMemoryMaped: ")+
(parameter.GetRawWayDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("RawWayIndexCacheSize: ")+
osmscout::NumberToString(parameter.GetRawWayIndexCacheSize()));
progress.Info(std::string("RawWayBlockSize: ")+
osmscout::NumberToString(parameter.GetRawWayBlockSize()));
progress.Info(std::string("SortObjects: ")+
(parameter.GetSortObjects() ? "true" : "false"));
progress.Info(std::string("SortBlockSize: ")+
osmscout::NumberToString(parameter.GetSortBlockSize()));
progress.Info(std::string("AreaDataMemoryMaped: ")+
(parameter.GetAreaDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("AreaDataCacheSize: ")+
osmscout::NumberToString(parameter.GetAreaDataCacheSize()));
progress.Info(std::string("WayDataMemoryMaped: ")+
(parameter.GetWayDataMemoryMaped() ? "true" : "false"));
progress.Info(std::string("WayDataCacheSize: ")+
osmscout::NumberToString(parameter.GetWayDataCacheSize()));
progress.Info(std::string("RouteNodeBlockSize: ")+
osmscout::NumberToString(parameter.GetRouteNodeBlockSize()));
bool result=osmscout::Import(parameter,
progress);
progress.SetStep("Summary");
if (result) {
double dataSize=0;
if (!CountDataSize(parameter,
progress,
dataSize)) {
progress.Error("Error while retrieving data size");
}
else {
progress.Info(std::string("Resulting data size: ")+osmscout::ByteSizeToString(dataSize));
}
progress.Info("Import OK!");
}
else {
progress.Error("Import failed!");
}
return 0;
}
bool lcApplication::Initialize(int argc, char* argv[], const char* LibraryInstallPath, const char* LDrawPath, const char* LibraryCachePath)
{
char* LibPath = LIBPATH_DEFAULT;
// Image output options.
bool SaveImage = false;
bool SaveWavefront = false;
bool Save3DS = false;
// bool ImageHighlight = false;
int ImageWidth = lcGetProfileInt(LC_PROFILE_IMAGE_WIDTH);
int ImageHeight = lcGetProfileInt(LC_PROFILE_IMAGE_HEIGHT);
lcStep ImageStart = 0;
lcStep ImageEnd = 0;
char* ImageName = NULL;
char* ProjectName = NULL;
char* SaveWavefrontName = NULL;
char* Save3DSName = NULL;
// Parse the command line arguments.
for (int i = 1; i < argc; i++)
{
char* Param = argv[i];
if (Param[0] == '-')
{
if ((strcmp(Param, "-l") == 0) || (strcmp(Param, "--libpath") == 0))
{
ParseStringArgument(&i, argc, argv, &LibPath);
}
else if ((strcmp(Param, "-i") == 0) || (strcmp(Param, "--image") == 0))
{
SaveImage = true;
if ((argc > (i+1)) && (argv[i+1][0] != '-'))
{
i++;
ImageName = argv[i];
}
}
else if ((strcmp(Param, "-w") == 0) || (strcmp(Param, "--width") == 0))
{
ParseIntegerArgument(&i, argc, argv, &ImageWidth);
}
else if ((strcmp(Param, "-h") == 0) || (strcmp(Param, "--height") == 0))
{
ParseIntegerArgument(&i, argc, argv, &ImageHeight);
}
else if ((strcmp(Param, "-f") == 0) || (strcmp(Param, "--from") == 0))
{
int Step;
ParseIntegerArgument(&i, argc, argv, &Step);
ImageStart = Step;
}
else if ((strcmp(Param, "-t") == 0) || (strcmp(Param, "--to") == 0))
{
int Step;
ParseIntegerArgument(&i, argc, argv, &Step);
ImageEnd = Step;
}
// else if (strcmp(Param, "--highlight") == 0)
// ImageHighlight = true;
else if ((strcmp(Param, "-wf") == 0) || (strcmp(Param, "--export-wavefront") == 0))
{
SaveWavefront = true;
if ((argc > (i+1)) && (argv[i+1][0] != '-'))
{
i++;
SaveWavefrontName = argv[i];
}
}
else if ((strcmp(Param, "-3ds") == 0) || (strcmp(Param, "--export-3ds") == 0))
{
Save3DS = true;
if ((argc > (i+1)) && (argv[i+1][0] != '-'))
{
i++;
Save3DSName = argv[i];
}
}
else if ((strcmp(Param, "-v") == 0) || (strcmp(Param, "--version") == 0))
{
printf("LeoCAD Version " LC_VERSION_TEXT "\n");
printf("Compiled " __DATE__ "\n");
return false;
}
else if ((strcmp(Param, "-?") == 0) || (strcmp(Param, "--help") == 0))
{
printf("Usage: leocad [options] [file]\n");
printf(" [options] can be:\n");
printf(" -l, --libpath <path>: Loads the Pieces Library from path.\n");
printf(" -i, --image <outfile.ext>: Saves a picture in the format specified by ext.\n");
printf(" -w, --width <width>: Sets the picture width.\n");
printf(" -h, --height <height>: Sets the picture height.\n");
printf(" -f, --from <time>: Sets the first frame or step to save pictures.\n");
printf(" -t, --to <time>: Sets the last frame or step to save pictures.\n");
// printf(" --highlight: Highlight pieces in the steps they appear.\n");
printf(" -wf, --export-wavefront <outfile.obj>: Exports the model to Wavefront format.\n");
printf(" -3ds, --export-3ds <outfile.3ds>: Exports the model to 3DS format.\n");
printf(" \n");
return false;
}
else
printf("Unknown parameter: %s\n", Param);
}
else
{
ProjectName = Param;
}
}
gMainWindow = new lcMainWindow();
lcLoadDefaultKeyboardShortcuts();
if (!LoadPiecesLibrary(LibPath, LibraryInstallPath, LDrawPath, LibraryCachePath))
{
if (SaveImage || SaveWavefront || Save3DS)
{
fprintf(stderr, "ERROR: Cannot load pieces library.");
return false;
}
if (mLibrary->LoadBuiltinPieces())
QMessageBox::information(gMainWindow, tr("LeoCAD"), tr("LeoCAD could not find a compatible Parts Library so only a small number of parts will be available.\n\n"
"Please visit http://www.leocad.org for information on how to download and install a library."));
else
QMessageBox::information(gMainWindow, tr("LeoCAD"), tr("LeoCAD could not load Parts Library.\n\n"
"Please visit http://www.leocad.org for information on how to download and install a library."));
}
gMainWindow->CreateWidgets();
// Create a new project.
Project* NewProject = new Project();
SetProject(NewProject);
// Load project.
if (ProjectName && gMainWindow->OpenProject(ProjectName))
{
if (SaveImage)
{
QString FileName;
if (ImageName)
FileName = ImageName;
else
FileName = ProjectName;
QString Extension = QFileInfo(FileName).suffix().toLower();
if (Extension.isEmpty())
{
FileName += lcGetProfileString(LC_PROFILE_IMAGE_EXTENSION);
}
else if (Extension != "bmp" && Extension != "jpg" && Extension != "jpeg" && Extension != "png")
{
FileName = FileName.left(FileName.length() - Extension.length() - 1);
FileName += lcGetProfileString(LC_PROFILE_IMAGE_EXTENSION);
}
if (ImageEnd < ImageStart)
ImageEnd = ImageStart;
else if (ImageStart > ImageEnd)
ImageStart = ImageEnd;
if ((ImageStart == 0) && (ImageEnd == 0))
{
ImageStart = ImageEnd = mProject->GetActiveModel()->GetCurrentStep();
}
else if ((ImageStart == 0) && (ImageEnd != 0))
{
ImageStart = ImageEnd;
}
else if ((ImageStart != 0) && (ImageEnd == 0))
{
ImageEnd = ImageStart;
}
if (ImageStart > 255)
ImageStart = 255;
if (ImageEnd > 255)
ImageEnd = 255;
QString Frame;
if (ImageStart != ImageEnd)
{
QString Extension = QFileInfo(FileName).suffix();
Frame = FileName.left(FileName.length() - Extension.length() - 1) + QLatin1String("%1.") + Extension;
}
else
Frame = FileName;
lcGetActiveModel()->SaveStepImages(Frame, ImageWidth, ImageHeight, ImageStart, ImageEnd);
}
if (SaveWavefront)
{
QString FileName;
if (SaveWavefrontName)
FileName = SaveWavefrontName;
else
FileName = ProjectName;
QString Extension = QFileInfo(FileName).suffix().toLower();
if (Extension.isEmpty())
{
FileName += ".obj";
}
else if (Extension != "obj")
{
FileName = FileName.left(FileName.length() - Extension.length() - 1);
FileName += ".obj";
}
mProject->ExportWavefront(FileName);
}
if (Save3DS)
{
QString FileName;
if (Save3DSName)
FileName = Save3DSName;
else
FileName = ProjectName;
QString Extension = QFileInfo(FileName).suffix().toLower();
if (Extension.isEmpty())
{
FileName += ".3ds";
}
else if (Extension != "3ds")
{
FileName = FileName.left(FileName.length() - Extension.length() - 1);
FileName += ".3ds";
}
mProject->Export3DStudio(FileName);
}
}
if (SaveImage || SaveWavefront || Save3DS)
return false;
return true;
}