git.gag.com Git - debian/openrocket/blob - src/net/sf/openrocket/file/openrocket/OpenRocketSaver.java

   1 package net.sf.openrocket.file.openrocket;
   2
   3 import java.io.BufferedWriter;
   4 import java.io.IOException;
   5 import java.io.OutputStream;
   6 import java.io.OutputStreamWriter;
   7 import java.io.Writer;
   8 import java.util.ArrayList;
   9 import java.util.Iterator;
  10 import java.util.List;
  11 import java.util.zip.GZIPOutputStream;
  12
  13 import net.sf.openrocket.aerodynamics.Warning;
  14 import net.sf.openrocket.document.OpenRocketDocument;
  15 import net.sf.openrocket.document.Simulation;
  16 import net.sf.openrocket.document.StorageOptions;
  17 import net.sf.openrocket.file.RocketSaver;
  18 import net.sf.openrocket.logging.LogHelper;
  19 import net.sf.openrocket.rocketcomponent.FinSet;
  20 import net.sf.openrocket.rocketcomponent.MotorMount;
  21 import net.sf.openrocket.rocketcomponent.Rocket;
  22 import net.sf.openrocket.rocketcomponent.RocketComponent;
  23 import net.sf.openrocket.rocketcomponent.TubeCoupler;
  24 import net.sf.openrocket.simulation.FlightData;
  25 import net.sf.openrocket.simulation.FlightDataBranch;
  26 import net.sf.openrocket.simulation.FlightDataType;
  27 import net.sf.openrocket.simulation.FlightEvent;
  28 import net.sf.openrocket.simulation.SimulationOptions;
  29 import net.sf.openrocket.startup.Application;
  30 import net.sf.openrocket.util.BugException;
  31 import net.sf.openrocket.util.MathUtil;
  32 import net.sf.openrocket.util.Prefs;
  33 import net.sf.openrocket.util.Reflection;
  34 import net.sf.openrocket.util.TextUtil;
  35
  36 public class OpenRocketSaver extends RocketSaver {
  37         private static final LogHelper log = Application.getLogger();
  38
  39
  40         /**
  41          * Divisor used in converting an integer version to the point-represented version.
  42          * The integer version divided by this value is the major version and the remainder is
  43          * the minor version.  For example 101 corresponds to file version "1.1".
  44          */
  45         public static final int FILE_VERSION_DIVISOR = 100;
  46
  47
  48         private static final String OPENROCKET_CHARSET = "UTF-8";
  49
  50         private static final String METHOD_PACKAGE = "net.sf.openrocket.file.openrocket.savers";
  51         private static final String METHOD_SUFFIX = "Saver";
  52
  53
  54         // Estimated storage used by different portions
  55         // These have been hand-estimated from saved files
  56         private static final int BYTES_PER_COMPONENT_UNCOMPRESSED = 590;
  57         private static final int BYTES_PER_COMPONENT_COMPRESSED = 80;
  58         private static final int BYTES_PER_SIMULATION_UNCOMPRESSED = 1000;
  59         private static final int BYTES_PER_SIMULATION_COMPRESSED = 100;
  60         private static final int BYTES_PER_DATAPOINT_UNCOMPRESSED = 350;
  61         private static final int BYTES_PER_DATAPOINT_COMPRESSED = 100;
  62
  63
  64         private int indent;
  65         private Writer dest;
  66
  67         @Override
  68         public void save(OutputStream output, OpenRocketDocument document, StorageOptions options)
  69                         throws IOException {
  70
  71                 log.info("Saving .ork file");
  72
  73                 if (options.isCompressionEnabled()) {
  74                         log.debug("Enabling compression");
  75                         output = new GZIPOutputStream(output);
  76                 }
  77
  78                 dest = new BufferedWriter(new OutputStreamWriter(output, OPENROCKET_CHARSET));
  79
  80                 // Select file version number
  81                 final int fileVersion = calculateNecessaryFileVersion(document, options);
  82                 final String fileVersionString =
  83                                 (fileVersion / FILE_VERSION_DIVISOR) + "." + (fileVersion % FILE_VERSION_DIVISOR);
  84                 log.debug("Storing file version " + fileVersionString);
  85
  86
  87                 this.indent = 0;
  88
  89
  90                 writeln("<?xml version='1.0' encoding='utf-8'?>");
  91                 writeln("<openrocket version=\"" + fileVersionString + "\" creator=\"OpenRocket "
  92                                 + Prefs.getVersion() + "\">");
  93                 indent++;
  94
  95                 // Recursively save the rocket structure
  96                 saveComponent(document.getRocket());
  97
  98                 writeln("");
  99
 100                 // Save all simulations
 101                 writeln("<simulations>");
 102                 indent++;
 103                 boolean first = true;
 104                 for (Simulation s : document.getSimulations()) {
 105                         if (!first)
 106                                 writeln("");
 107                         first = false;
 108                         saveSimulation(s, options.getSimulationTimeSkip());
 109                 }
 110                 indent--;
 111                 writeln("</simulations>");
 112
 113                 indent--;
 114                 writeln("</openrocket>");
 115
 116                 log.debug("Writing complete, flushing buffers");
 117                 dest.flush();
 118                 if (options.isCompressionEnabled()) {
 119                         ((GZIPOutputStream) output).finish();
 120                 }
 121         }
 122
 123
 124
 125         @Override
 126         public long estimateFileSize(OpenRocketDocument doc, StorageOptions options) {
 127
 128                 long size = 0;
 129
 130                 // Size per component
 131                 int componentCount = 0;
 132                 Rocket rocket = doc.getRocket();
 133                 Iterator<RocketComponent> iterator = rocket.iterator(true);
 134                 while (iterator.hasNext()) {
 135                         iterator.next();
 136                         componentCount++;
 137                 }
 138
 139                 if (options.isCompressionEnabled())
 140                         size += componentCount * BYTES_PER_COMPONENT_COMPRESSED;
 141                 else
 142                         size += componentCount * BYTES_PER_COMPONENT_UNCOMPRESSED;
 143
 144
 145                 // Size per simulation
 146                 if (options.isCompressionEnabled())
 147                         size += doc.getSimulationCount() * BYTES_PER_SIMULATION_COMPRESSED;
 148                 else
 149                         size += doc.getSimulationCount() * BYTES_PER_SIMULATION_UNCOMPRESSED;
 150
 151
 152                 // Size per flight data point
 153                 int pointCount = 0;
 154                 double timeSkip = options.getSimulationTimeSkip();
 155                 if (timeSkip != StorageOptions.SIMULATION_DATA_NONE) {
 156                         for (Simulation s : doc.getSimulations()) {
 157                                 FlightData data = s.getSimulatedData();
 158                                 if (data != null) {
 159                                         for (int i = 0; i < data.getBranchCount(); i++) {
 160                                                 pointCount += countFlightDataBranchPoints(data.getBranch(i), timeSkip);
 161                                         }
 162                                 }
 163                         }
 164                 }
 165
 166                 if (options.isCompressionEnabled())
 167                         size += pointCount * BYTES_PER_DATAPOINT_COMPRESSED;
 168                 else
 169                         size += pointCount * BYTES_PER_DATAPOINT_UNCOMPRESSED;
 170
 171                 return size;
 172         }
 173
 174
 175         /**
 176          * Determine which file version is required in order to store all the features of the
 177          * current design.  By default the oldest version that supports all the necessary features
 178          * will be used.
 179          *
 180          * @param document      the document to output.
 181          * @param opts          the storage options.
 182          * @return                      the integer file version to use.
 183          */
 184         private int calculateNecessaryFileVersion(OpenRocketDocument document, StorageOptions opts) {
 185                 /*
 186                  * File version 1.2 is required for:
 187                  *  - saving motor data
 188                  *
 189                  * File version 1.1 is required for:
 190                  *  - fin tabs
 191                  *  - components attached to tube coupler
 192                  *
 193                  * Otherwise use version 1.0.
 194                  */
 195
 196                 // Check if design has simulations defined (version 1.3)
 197                 if (document.getSimulationCount() > 0) {
 198                         return FILE_VERSION_DIVISOR + 3;
 199                 }
 200
 201                 // Check for motor definitions (version 1.2)
 202                 Iterator<RocketComponent> iterator = document.getRocket().iterator();
 203                 while (iterator.hasNext()) {
 204                         RocketComponent c = iterator.next();
 205                         if (!(c instanceof MotorMount))
 206                                 continue;
 207
 208                         MotorMount mount = (MotorMount) c;
 209                         for (String id : document.getRocket().getMotorConfigurationIDs()) {
 210                                 if (mount.getMotor(id) != null) {
 211                                         return FILE_VERSION_DIVISOR + 2;
 212                                 }
 213                         }
 214                 }
 215
 216                 // Check for fin tabs (version 1.1)
 217                 iterator = document.getRocket().iterator();
 218                 while (iterator.hasNext()) {
 219                         RocketComponent c = iterator.next();
 220
 221                         // Check for fin tabs
 222                         if (c instanceof FinSet) {
 223                                 FinSet fin = (FinSet) c;
 224                                 if (!MathUtil.equals(fin.getTabHeight(), 0) &&
 225                                                 !MathUtil.equals(fin.getTabLength(), 0)) {
 226                                         return FILE_VERSION_DIVISOR + 1;
 227                                 }
 228                         }
 229
 230                         // Check for components attached to tube coupler
 231                         if (c instanceof TubeCoupler) {
 232                                 if (c.getChildCount() > 0) {
 233                                         return FILE_VERSION_DIVISOR + 1;
 234                                 }
 235                         }
 236                 }
 237
 238                 // Default (version 1.0)
 239                 return FILE_VERSION_DIVISOR + 0;
 240         }
 241
 242
 243
 244         @SuppressWarnings("unchecked")
 245         private void saveComponent(RocketComponent component) throws IOException {
 246
 247                 log.debug("Saving component " + component.getComponentName());
 248
 249                 Reflection.Method m = Reflection.findMethod(METHOD_PACKAGE, component, METHOD_SUFFIX,
 250                                 "getElements", RocketComponent.class);
 251                 if (m == null) {
 252                         throw new BugException("Unable to find saving class for component " +
 253                                         component.getComponentName());
 254                 }
 255
 256                 // Get the strings to save
 257                 List<String> list = (List<String>) m.invokeStatic(component);
 258                 int length = list.size();
 259
 260                 if (length == 0) // Nothing to do
 261                         return;
 262
 263                 if (length < 2) {
 264                         throw new RuntimeException("BUG, component data length less than two lines.");
 265                 }
 266
 267                 // Open element
 268                 writeln(list.get(0));
 269                 indent++;
 270
 271                 // Write parameters
 272                 for (int i = 1; i < length - 1; i++) {
 273                         writeln(list.get(i));
 274                 }
 275
 276                 // Recursively write subcomponents
 277                 if (component.getChildCount() > 0) {
 278                         writeln("");
 279                         writeln("<subcomponents>");
 280                         indent++;
 281                         boolean emptyline = false;
 282                         for (RocketComponent subcomponent : component.getChildren()) {
 283                                 if (emptyline)
 284                                         writeln("");
 285                                 emptyline = true;
 286                                 saveComponent(subcomponent);
 287                         }
 288                         indent--;
 289                         writeln("</subcomponents>");
 290                 }
 291
 292                 // Close element
 293                 indent--;
 294                 writeln(list.get(length - 1));
 295         }
 296
 297
 298         private void saveSimulation(Simulation simulation, double timeSkip) throws IOException {
 299                 SimulationOptions cond = simulation.getOptions();
 300
 301                 writeln("<simulation status=\"" + enumToXMLName(simulation.getStatus()) + "\">");
 302                 indent++;
 303
 304                 writeln("<name>" + escapeXML(simulation.getName()) + "</name>");
 305                 // TODO: MEDIUM: Other simulators/calculators
 306                 writeln("<simulator>RK4Simulator</simulator>");
 307                 writeln("<calculator>BarrowmanCalculator</calculator>");
 308                 writeln("<conditions>");
 309                 indent++;
 310
 311                 writeElement("configid", cond.getMotorConfigurationID());
 312                 writeElement("launchrodlength", cond.getLaunchRodLength());
 313                 writeElement("launchrodangle", cond.getLaunchRodAngle() * 180.0 / Math.PI);
 314                 writeElement("launchroddirection", cond.getLaunchRodDirection() * 180.0 / Math.PI);
 315                 writeElement("windaverage", cond.getWindSpeedAverage());
 316                 writeElement("windturbulence", cond.getWindTurbulenceIntensity());
 317                 writeElement("launchaltitude", cond.getLaunchAltitude());
 318                 writeElement("launchlatitude", cond.getLaunchLatitude());
 319                 writeElement("launchlongitude", cond.getLaunchLongitude());
 320                 writeElement("geodeticmethod", cond.getGeodeticComputation().name().toLowerCase());
 321
 322                 if (cond.isISAAtmosphere()) {
 323                         writeln("<atmosphere model=\"isa\"/>");
 324                 } else {
 325                         writeln("<atmosphere model=\"extendedisa\">");
 326                         indent++;
 327                         writeElement("basetemperature", cond.getLaunchTemperature());
 328                         writeElement("basepressure", cond.getLaunchPressure());
 329                         indent--;
 330                         writeln("</atmosphere>");
 331                 }
 332
 333                 writeElement("timestep", cond.getTimeStep());
 334
 335                 indent--;
 336                 writeln("</conditions>");
 337
 338
 339                 for (String s : simulation.getSimulationListeners()) {
 340                         writeElement("listener", escapeXML(s));
 341                 }
 342
 343
 344                 // Write basic simulation data
 345
 346                 FlightData data = simulation.getSimulatedData();
 347                 if (data != null) {
 348                         String str = "<flightdata";
 349                         if (!Double.isNaN(data.getMaxAltitude()))
 350                                 str += " maxaltitude=\"" + TextUtil.doubleToString(data.getMaxAltitude()) + "\"";
 351                         if (!Double.isNaN(data.getMaxVelocity()))
 352                                 str += " maxvelocity=\"" + TextUtil.doubleToString(data.getMaxVelocity()) + "\"";
 353                         if (!Double.isNaN(data.getMaxAcceleration()))
 354                                 str += " maxacceleration=\"" + TextUtil.doubleToString(data.getMaxAcceleration()) + "\"";
 355                         if (!Double.isNaN(data.getMaxMachNumber()))
 356                                 str += " maxmach=\"" + TextUtil.doubleToString(data.getMaxMachNumber()) + "\"";
 357                         if (!Double.isNaN(data.getTimeToApogee()))
 358                                 str += " timetoapogee=\"" + TextUtil.doubleToString(data.getTimeToApogee()) + "\"";
 359                         if (!Double.isNaN(data.getFlightTime()))
 360                                 str += " flighttime=\"" + TextUtil.doubleToString(data.getFlightTime()) + "\"";
 361                         if (!Double.isNaN(data.getGroundHitVelocity()))
 362                                 str += " groundhitvelocity=\"" + TextUtil.doubleToString(data.getGroundHitVelocity()) + "\"";
 363                         str += ">";
 364                         writeln(str);
 365                         indent++;
 366
 367                         for (Warning w : data.getWarningSet()) {
 368                                 writeElement("warning", escapeXML(w.toString()));
 369                         }
 370
 371                         // Check whether to store data
 372                         if (simulation.getStatus() == Simulation.Status.EXTERNAL) // Always store external data
 373                                 timeSkip = 0;
 374
 375                         if (timeSkip != StorageOptions.SIMULATION_DATA_NONE) {
 376                                 for (int i = 0; i < data.getBranchCount(); i++) {
 377                                         FlightDataBranch branch = data.getBranch(i);
 378                                         saveFlightDataBranch(branch, timeSkip);
 379                                 }
 380                         }
 381
 382                         indent--;
 383                         writeln("</flightdata>");
 384                 }
 385
 386                 indent--;
 387                 writeln("</simulation>");
 388
 389         }
 390
 391
 392
 393         private void saveFlightDataBranch(FlightDataBranch branch, double timeSkip)
 394                         throws IOException {
 395                 double previousTime = -100000;
 396
 397                 if (branch == null)
 398                         return;
 399
 400                 // Retrieve the types from the branch
 401                 FlightDataType[] types = branch.getTypes();
 402
 403                 if (types.length == 0)
 404                         return;
 405
 406                 // Retrieve the data from the branch
 407                 List<List<Double>> data = new ArrayList<List<Double>>(types.length);
 408                 for (int i = 0; i < types.length; i++) {
 409                         data.add(branch.get(types[i]));
 410                 }
 411                 List<Double> timeData = branch.get(FlightDataType.TYPE_TIME);
 412
 413                 // Build the <databranch> tag
 414                 StringBuilder sb = new StringBuilder();
 415                 sb.append("<databranch name=\"");
 416                 sb.append(escapeXML(branch.getBranchName()));
 417                 sb.append("\" types=\"");
 418                 for (int i = 0; i < types.length; i++) {
 419                         if (i > 0)
 420                                 sb.append(",");
 421                         sb.append(escapeXML(types[i].getName()));
 422                 }
 423                 sb.append("\">");
 424                 writeln(sb.toString());
 425                 indent++;
 426
 427                 // Write events
 428                 for (FlightEvent event : branch.getEvents()) {
 429                         writeln("<event time=\"" + TextUtil.doubleToString(event.getTime())
 430                                         + "\" type=\"" + enumToXMLName(event.getType()) + "\"/>");
 431                 }
 432
 433                 // Write the data
 434                 int length = branch.getLength();
 435                 if (length > 0) {
 436                         writeDataPointString(data, 0, sb);
 437                         previousTime = timeData.get(0);
 438                 }
 439
 440                 for (int i = 1; i < length - 1; i++) {
 441                         if (timeData != null) {
 442                                 if (Math.abs(timeData.get(i) - previousTime - timeSkip) < Math.abs(timeData.get(i + 1) - previousTime - timeSkip)) {
 443                                         writeDataPointString(data, i, sb);
 444                                         previousTime = timeData.get(i);
 445                                 }
 446                         } else {
 447                                 // If time data is not available, write all points
 448                                 writeDataPointString(data, i, sb);
 449                         }
 450                 }
 451
 452                 if (length > 1) {
 453                         writeDataPointString(data, length - 1, sb);
 454                 }
 455
 456                 indent--;
 457                 writeln("</databranch>");
 458         }
 459
 460
 461
 462         /* TODO: LOW: This is largely duplicated from above! */
 463         private int countFlightDataBranchPoints(FlightDataBranch branch, double timeSkip) {
 464                 int count = 0;
 465
 466                 double previousTime = -100000;
 467
 468                 if (branch == null)
 469                         return 0;
 470
 471                 // Retrieve the types from the branch
 472                 FlightDataType[] types = branch.getTypes();
 473
 474                 if (types.length == 0)
 475                         return 0;
 476
 477                 List<Double> timeData = branch.get(FlightDataType.TYPE_TIME);
 478                 if (timeData == null) {
 479                         // If time data not available, store all points
 480                         return branch.getLength();
 481                 }
 482
 483                 // Write the data
 484                 int length = branch.getLength();
 485                 if (length > 0) {
 486                         count++;
 487                         previousTime = timeData.get(0);
 488                 }
 489
 490                 for (int i = 1; i < length - 1; i++) {
 491                         if (Math.abs(timeData.get(i) - previousTime - timeSkip) < Math.abs(timeData.get(i + 1) - previousTime - timeSkip)) {
 492                                 count++;
 493                                 previousTime = timeData.get(i);
 494                         }
 495                 }
 496
 497                 if (length > 1) {
 498                         count++;
 499                 }
 500
 501                 return count;
 502         }
 503
 504
 505
 506         private void writeDataPointString(List<List<Double>> data, int index, StringBuilder sb)
 507                         throws IOException {
 508                 sb.setLength(0);
 509                 sb.append("<datapoint>");
 510                 for (int j = 0; j < data.size(); j++) {
 511                         if (j > 0)
 512                                 sb.append(",");
 513                         sb.append(TextUtil.doubleToString(data.get(j).get(index)));
 514                 }
 515                 sb.append("</datapoint>");
 516                 writeln(sb.toString());
 517         }
 518
 519
 520
 521         private void writeElement(String element, Object content) throws IOException {
 522                 if (content == null)
 523                         content = "";
 524                 writeln("<" + element + ">" + content + "</" + element + ">");
 525         }
 526
 527
 528
 529         private void writeln(String str) throws IOException {
 530                 if (str.length() == 0) {
 531                         dest.write("\n");
 532                         return;
 533                 }
 534                 String s = "";
 535                 for (int i = 0; i < indent; i++)
 536                         s = s + "  ";
 537                 s = s + str + "\n";
 538                 dest.write(s);
 539         }
 540
 541
 542
 543
 544         /**
 545          * Return the XML equivalent of an enum name.
 546          *
 547          * @param e             the enum to save.
 548          * @return              the corresponding XML name.
 549          */
 550         public static String enumToXMLName(Enum<?> e) {
 551                 return e.name().toLowerCase().replace("_", "");
 552         }
 553
 554 }