cosmos 3.0.0

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_config.rb

@@ -0,0 +1,430 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/ext/tabbed_plots_config'
+require 'cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_tab'
+require 'cosmos/tools/tlm_grapher/plots/plot'
+require 'cosmos/tools/tlm_grapher/plots/linegraph_plot'
+require 'cosmos/tools/tlm_grapher/plots/xy_plot'
+require 'cosmos/tools/tlm_grapher/plots/singlexy_plot'
+require 'cosmos/tools/tlm_grapher/data_objects/data_object'
+require 'cosmos/tools/tlm_grapher/data_objects/linegraph_data_object'
+require 'cosmos/tools/tlm_grapher/data_objects/housekeeping_data_object'
+require 'cosmos/tools/tlm_grapher/data_objects/xy_data_object'
+require 'cosmos/tools/tlm_grapher/data_objects/singlexy_data_object'
+
+module Cosmos
+
+  # Provides capabilities to read an ascii file that lists
+  # the details for a set of plots drawn in tabs.
+  class TabbedPlotsConfig
+
+    # Default Values
+    DEFAULT_SECONDS_PLOTTED = 100.0
+    DEFAULT_POINTS_SAVED = 1000000
+    DEFAULT_POINTS_PLOTTED = 1000
+    DEFAULT_REFRESH_RATE_HZ = 10.0
+
+    # Gives access to the array of tabs defined by the configuration file
+    attr_accessor :tabs
+
+    # Global Seconds Plotted Setting
+    attr_accessor :seconds_plotted
+
+    # Global Points Saved Setting
+    attr_accessor :points_saved
+
+    # Global Points Plotted Setting
+    attr_accessor :points_plotted
+
+    # Global Refresh Rate Hz Setting
+    attr_accessor :refresh_rate_hz
+
+    # Plot types known by this tabbed plots definition
+    attr_accessor :plot_types
+
+    # Data object types known by this tabbed plots definition
+    attr_accessor :data_object_types
+
+    # Mapping of what data object types a plot can handle
+    attr_accessor :plot_type_to_data_object_type_mapping
+
+    # Gives access to array of errors that occurred while processing configuration file
+    attr_accessor :configuration_errors
+
+    # Processes a file and adds in the configuration defined in the file
+    def initialize(filename,
+                   plot_types,
+                   data_object_types,
+                   plot_type_to_data_object_type_mapping)
+      @plot_types = plot_types
+      @data_object_types = data_object_types
+      @plot_type_to_data_object_type_mapping = plot_type_to_data_object_type_mapping
+
+      @mutex = Mutex.new
+      @tabs = []
+      @points_saved = DEFAULT_POINTS_SAVED
+      @seconds_plotted = DEFAULT_SECONDS_PLOTTED
+      @points_plotted = DEFAULT_POINTS_PLOTTED
+      @refresh_rate_hz = DEFAULT_REFRESH_RATE_HZ
+      @packet_count = 0
+      @configuration_errors = []
+
+      if File.exist?(filename.to_s)
+        # Loop over each line of the configuration file
+        parser = ConfigParser.new
+        parser.parse_file(filename) do |keyword, parameters|
+          begin
+            # Handle each keyword
+            case keyword
+
+            when 'TAB'
+              # Expect 0 or 1 parameter
+              parser.verify_num_parameters(0, 1, "TAB <Tab Text (optional)>")
+
+              # Add a new tab to the array of tabs
+              add_tab(parameters[0])
+
+            when 'PLOT'
+              # Expect 1 parameter
+              parser.verify_num_parameters(1, 1, "PLOT <Plot Type>")
+
+              # Add a new plot to the current tab
+              add_plot(-1, create_plot(parameters[0]))
+
+            when 'DATA_OBJECT'
+              # Expect 1 parameter
+              parser.verify_num_parameters(1, 1, "DATA_OBJECT <Data Object Type>")
+
+              # Require data object file
+              data_object_filename = parameters[0].downcase << '_data_object.rb'
+              data_object = Cosmos.require_class(data_object_filename).new
+              data_object.plot = @tabs[-1].plots[-1]
+
+              # Add a new data object to the current plot
+              @tabs[-1].plots[-1].data_objects << data_object
+
+            else
+              # Unknown keywords are passed to the current data object or current plot if there is a current tab
+              current_tab = @tabs[-1]
+              if current_tab
+                current_plot = current_tab.plots[-1]
+                if current_plot
+                  current_data_object = current_plot.data_objects[-1]
+                  if current_data_object
+                    current_data_object.handle_keyword(parser, keyword, parameters)
+                  else
+                    current_plot.handle_keyword(parser, keyword, parameters)
+                  end
+                else
+                  raise ArgumentError, "A PLOT must be defined before using keyword: #{keyword}"
+                end
+              else
+                case keyword
+                when 'POINTS_SAVED'
+                  # Expect 1 parameter
+                  parser.verify_num_parameters(1, 1, "POINTS_SAVED <Points Saved>")
+
+                  # Update Points Saved
+                  @points_saved = parameters[0].to_i
+
+                when 'SECONDS_PLOTTED'
+                  # Expect 1 parameter
+                  parser.verify_num_parameters(1, 1, "SECONDS_PLOTTED <Seconds Plotted>")
+
+                  # Update Seconds Plotted
+                  @seconds_plotted = parameters[0].to_f
+
+                when 'POINTS_PLOTTED'
+                  # Expect 1 parameter
+                  parser.verify_num_parameters(1, 1, "POINTS_PLOTTED <Points Plotted>")
+
+                  # Update Points Plotted
+                  @points_plotted = Integer(parameters[0])
+
+                when 'REFRESH_RATE_HZ'
+                  # Expect 1 parameter
+                  parser.verify_num_parameters(1, 1, "REFRESH_RATE_HZ <Refresh Rate in Hz>")
+
+                  # Update Points Plotted
+                  @refresh_rate_hz = parameters[0].to_f
+                  raise ArgumentError, "Invalid Refresh Rate Hz: #{@refresh_rate_hz}" if @refresh_rate_hz <= 0.0
+
+                else
+                  # Handle unknown keywords
+                  raise ArgumentError, "A TAB must be defined before using keyword: #{keyword}"
+
+                end
+              end
+
+            end # case keyword
+          rescue Exception => error
+            @configuration_errors << error
+          end
+        end # CosmosConfig.each
+      else
+        # Use default config of one tab and one plot
+        add_tab()
+        add_plot(-1, create_plot(@plot_types[0]))
+      end
+
+      # Build initial packet to data object mapping
+      build_packet_to_data_objects_mapping()
+
+    end # end def initialize
+
+    # Returns the configuration
+    def configuration_string
+      @mutex.synchronize do
+        configuration = ''
+        configuration << "SECONDS_PLOTTED #{@seconds_plotted}\n"
+        configuration << "POINTS_SAVED #{@points_saved}\n"
+        configuration << "POINTS_PLOTTED #{@points_plotted}\n"
+        configuration << "REFRESH_RATE_HZ #{@refresh_rate_hz}\n"
+        @tabs.each do |tab|
+          configuration << "\n"
+          configuration << tab.configuration_string
+        end
+        configuration
+      end
+    end
+
+    # Adds a tab to the definition
+    def add_tab(tab_text = nil)
+      @mutex.synchronize do
+        # Add a new tab to the array of tabs
+        @tabs << TabbedPlotsTab.new(tab_text)
+        @tabs[-1]
+      end
+    end
+
+    # Removes a tab from the definition
+    def remove_tab(tab_index)
+      @mutex.synchronize do
+        @tabs.delete_at(tab_index)
+      end
+    end
+
+    # Creates a new plot object
+    def create_plot(plot_type, tab_index = -1)
+      @mutex.synchronize do
+        # Require plot file
+        plot_filename = plot_type.downcase << '_plot.rb'
+        Cosmos.require_class(plot_filename).new
+      end
+    end
+
+    # Adds a plot to the definition
+    def add_plot(tab_index, plot)
+      plot.tab = @tabs[tab_index]
+      @tabs[tab_index].plots << plot
+    end
+
+    # Removes a plot from the definition
+    def remove_plot(tab_index, plot_index)
+      @mutex.synchronize do
+        @tabs[tab_index].plots.delete_at(plot_index)
+      end
+    end
+
+    # Adds a data object to the definition
+    def add_data_object(tab_index, plot_index, data_object)
+      @mutex.synchronize do
+        plot = @tabs[tab_index].plots[plot_index]
+        data_object.plot = plot
+        plot.data_objects << data_object
+        build_packet_to_data_objects_mapping()
+        plot.redraw_needed = true
+        data_object
+      end
+    end
+
+    # Moves a data object from one index to another
+    def move_data_object(tab_index, plot_index, start_index, end_index)
+      @mutex.synchronize do
+        data_objects = @tabs[tab_index].plots[plot_index].data_objects
+        data_objects.insert(end_index, data_objects.delete_at(start_index))
+      end
+    end
+
+    # Removes a data object from the definition
+    def remove_data_object(tab_index, plot_index, data_object_index)
+      @mutex.synchronize do
+        plot = @tabs[tab_index].plots[plot_index]
+        plot.data_objects.delete_at(data_object_index)
+        build_packet_to_data_objects_mapping()
+        plot.redraw_needed = true
+      end
+    end
+
+    # Edits a data object in the definition
+    def edit_data_object(tab_index, plot_index, data_object_index, editted_data_object)
+      data_object = @tabs[tab_index].plots[plot_index].data_objects[data_object_index]
+      if data_object.edit_safe?(editted_data_object)
+        @mutex.synchronize do
+          data_object.edit(editted_data_object)
+        end
+      else
+        replace_data_object(tab_index, plot_index, data_object_index, editted_data_object)
+      end
+    end
+
+    # Duplicates a data object in the definition and adds it to the definition
+    def duplicate_data_object(tab_index, plot_index, data_object_index)
+      @mutex.synchronize do
+        plot = @tabs[tab_index].plots[plot_index]
+        data_object = plot.data_objects[data_object_index]
+        plot.data_objects << data_object.copy
+        build_packet_to_data_objects_mapping()
+        plot.data_objects[-1].plot = plot
+        plot.redraw_needed = true
+        plot.data_objects[-1]
+      end
+    end
+
+    # Replaces one data object in the definition with another
+    def replace_data_object(tab_index, plot_index, data_object_index, data_object)
+      @mutex.synchronize do
+        plot = @tabs[tab_index].plots[plot_index]
+        data_object.plot = plot
+        plot.data_objects[data_object_index] = data_object
+        build_packet_to_data_objects_mapping()
+        plot.redraw_needed = true
+      end
+    end
+
+    # Resets each data object
+    def reset_data_objects(tab_index = nil, plot_index = nil, data_object_index = nil)
+      @mutex.synchronize do
+        if data_object_index
+          @tabs[tab_index].plots[plot_index].data_objects[data_object_index].reset
+        elsif plot_index
+          @tabs[tab_index].plots[plot_index].data_objects.each {|data_object| data_object.reset}
+        elsif tab_index
+          @tabs[tab_index].plots.each {|plot| plot.data_objects.each {|data_object| data_object.reset}}
+        else
+          @tabs.each {|tab| tab.plots.each {|plot| plot.data_objects.each {|data_object| data_object.reset}}}
+        end
+      end
+    end
+
+    # Exports each data object
+    def export_data_objects(progress = nil, tab_index = nil, plot_index = nil, data_object_index = nil)
+      columns = []
+      @mutex.synchronize do
+        tabs = tab_index ? [@tabs[tab_index]] : @tabs
+        tabs.each do |tab|
+          plots = plot_index ? [tab.plots[plot_index]] : tab.plots
+          plots.each do |plot|
+            data_objects = data_object_index ? [plot.data_objects[data_object_index]] : plot.data_objects
+            data_objects.each do |data_object|
+              progress.append_text("Exporting #{data_object.name} on plot '#{plot.title}' on tab '#{tab.tab_text}'") if progress
+              columns.concat(data_object.export)
+            end
+          end
+        end
+      end
+      columns
+    end
+
+    # Processes a packet for all data objects that request it
+    def process_packet(packet)
+      # Increment packet count
+      @packet_count += 1
+
+      # Get target name and packet name
+      target_name = packet.target_name
+      packet_name = packet.packet_name
+
+      # Route packet to its data object(s)
+      if target_name and packet_name
+        index = target_name + ' ' + packet_name
+        @mutex.synchronize do
+          data_objects = @packet_to_data_objects_mapping[index]
+          process_packet_in_each_data_object(data_objects, packet, @packet_count) if data_objects
+        end
+      end
+    end
+
+    # Updates max points saved in each data object
+    def update_max_points_saved(total_points_saved)
+      @mutex.synchronize do
+        # Count number of data objects
+        num_data_objects = 0
+        each_data_object {|_| num_data_objects += 1}
+
+        if num_data_objects > 0
+          points_saved_per_data_object = total_points_saved / num_data_objects
+          points_saved_per_data_object = 1 if points_saved_per_data_object < 1
+          each_data_object do |data_object|
+            data_object.max_points_saved = points_saved_per_data_object
+          end
+        end
+      end
+    end
+
+    # Yields each data object (mutex must already be acquired before calling)
+    def each_data_object
+      @tabs.each do |tab|
+        tab.plots.each do |plot|
+          plot.data_objects.each do |data_object|
+            yield data_object
+          end
+        end
+      end
+    end
+
+    # Takes the mutex protecting the tabbed plot definition
+    def mu_synchronize
+      @mutex.synchronize do
+        yield
+      end
+    end
+
+    protected
+
+    # Optimization method to move each call to C code
+    # def process_packet_in_each_data_object(data_objects, packet, packet_count)
+
+    # Build (or rebuild) the mapping between packets and data objects that process them
+    # Note: This is an optimization to prevent looping through all the data objects
+    # when each packet is received.
+    def build_packet_to_data_objects_mapping
+      @packet_to_data_objects_mapping = {}
+
+      @tabs.each do |tab|
+        tab.plots.each do |plot|
+          plot.data_objects.each do |data_object|
+            data_object.processed_packets.each do |target_name, packet_name|
+              # Build the index into the hash of the form "TARGET_NAME PACKET_NAME"
+              # Note that + is used to create a new object and then << is used to concatenate
+              # to the new object.
+              if packet_name.casecmp(Telemetry::LATEST_PACKET_NAME) == 0
+                packets = System.telemetry.latest_packets(target_name, data_object.item_name)
+                packets.each do |packet|
+                  index = (packet.target_name + ' ') << packet.packet_name
+                  @packet_to_data_objects_mapping[index] ||= []
+                  @packet_to_data_objects_mapping[index] << data_object
+                end
+              else
+                index = (target_name + ' ') << packet_name
+                @packet_to_data_objects_mapping[index] ||= []
+                @packet_to_data_objects_mapping[index] << data_object
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end # class TabbedPlotsConfig
+
+end # module Cosmos

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_data_object_editor.rb

@@ -0,0 +1,107 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/tools/tlm_grapher/data_object_editors/data_object_editor'
+require 'cosmos/tools/tlm_grapher/data_object_editors/linegraph_data_object_editor'
+require 'cosmos/tools/tlm_grapher/data_object_editors/housekeeping_data_object_editor'
+require 'cosmos/tools/tlm_grapher/data_object_editors/xy_data_object_editor'
+require 'cosmos/tools/tlm_grapher/data_object_editors/singlexy_data_object_editor'
+
+module Cosmos
+
+  # Dialog which allows the user to edit the data object
+  class TabbedPlotsDataObjectEditor < Qt::Dialog
+
+    def initialize(parent, title, data_object_types, data_object = nil)
+      # Call base class constructor
+      super(parent)
+      setWindowTitle(title)
+
+      layout = Qt::VBoxLayout.new
+
+      unless data_object
+        # Create combobox to select data object type
+        @combobox = Qt::ComboBox.new(self)
+        data_object_types.each {|data_object_type| @combobox.addItem(data_object_type.to_s.upcase)}
+        @combobox.setMaxVisibleItems(data_object_types.length)
+        @combobox.connect(SIGNAL('currentIndexChanged(int)')) { handle_data_object_type_change(data_object) }
+        combo_layout = Qt::FormLayout.new()
+        combo_layout.addRow('Data Object Type:', @combobox)
+        layout.addLayout(combo_layout)
+
+        # Separator before actual editing dialog
+        sep1 = Qt::Frame.new
+        sep1.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Sunken)
+        layout.addWidget(sep1)
+      else
+        setWindowTitle(title + " : #{data_object.data_object_type}")
+      end
+
+      # Create editor class for specific data object type
+      # Defaults to data_object_types[0] if a data object was not given
+      if data_object
+        data_object_type = data_object.class.to_s[0..-11].downcase
+        data_object_type = data_object_type.split('::')[-1] # Remove Cosmos:: if present
+      else
+        data_object_type = data_object_types[0].to_s.downcase
+      end
+      @editor_layout = Qt::VBoxLayout.new
+      layout.addLayout(@editor_layout)
+      @editor = Cosmos.require_class(data_object_type + '_data_object_editor.rb').new(self)
+      @editor.set_data_object(data_object)
+      @editor_layout.addWidget(@editor)
+
+      # Separator before buttons
+      sep2 = Qt::Frame.new
+      sep2.setFrameStyle(Qt::Frame::HLine | Qt::Frame::Sunken)
+      layout.addWidget(sep2)
+      layout.addStretch
+
+      # Create OK and Cancel buttons
+      ok_button = Qt::PushButton.new('Ok')
+      ok_button.setDefault(true)
+      connect(ok_button, SIGNAL('clicked()'), self, SLOT('accept()'))
+      cancel_button = Qt::PushButton.new('Cancel')
+      connect(cancel_button, SIGNAL('clicked()'), self, SLOT('reject()'))
+      button_layout = Qt::HBoxLayout.new()
+      button_layout.addWidget(ok_button)
+      button_layout.addWidget(cancel_button)
+      layout.addLayout(button_layout)
+
+      setLayout(layout)
+    end # def initialize
+
+    # Executes the dialog box
+    def execute
+      return_value = nil
+      result = exec()
+      if result == Qt::Dialog::Accepted
+        return_value = @editor.get_data_object
+      end
+      dispose()
+      return return_value
+    end # def execute
+
+    protected
+
+    # Handles the data object type changing
+    def handle_data_object_type_change(data_object)
+      data_object_type = @combobox.text.downcase
+      @editor_layout.removeWidget(@editor)
+      @editor.dispose
+      @editor = Cosmos.require_class(data_object_type + '_data_object_editor.rb').new(self)
+      @editor.set_data_object(data_object)
+      @editor_layout.addWidget(@editor)
+    end
+
+  end # class TabbedPlotsDataObjectEditor
+
+end # module Cosmos

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_logfile_thread.rb

@@ -0,0 +1,95 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos'
+require 'cosmos/gui/qt'
+
+module Cosmos
+
+  # Thread used to gather telemetry from log file(s) and process it using a TabbedPlotsDefinition
+  class TabbedPlotsLogfileThread
+    # Number of packets between updating the progress bar
+    PROGRESS_UPDATE_PACKET_COUNT = 100
+
+    # Array of exceptions that occurred processing the log file
+    attr_reader :errors
+
+    # Create a new TabbedPlotsLogfileThread
+    def initialize(log_files, packet_log_reader, tabbed_plots_config, progress_dialog = nil, time_start = nil, time_end = nil)
+      super()
+      @packet_log_reader = packet_log_reader
+      @tabbed_plots_config = tabbed_plots_config
+      @errors = []
+      @done = false
+      @cancel = false
+
+      if progress_dialog
+        progress_dialog.cancel_callback = method(:kill)
+        progress_dialog.enable_cancel_button
+      end
+
+      @thread = Thread.new do
+        begin
+          log_file_count = 1
+          log_files.each do |log_file|
+            break if @cancel
+            begin
+              file_size = File.size(log_file).to_f
+              progress_dialog.append_text("Procesing File #{log_file_count}/#{log_files.length}: #{log_file}\n") if progress_dialog
+              progress_dialog.set_step_progress(0) if progress_dialog
+              packet_count = 0
+              @packet_log_reader.each(log_file, true, time_start, time_end) do |packet|
+                break if @cancel
+                if progress_dialog and packet_count % PROGRESS_UPDATE_PACKET_COUNT == 0
+                  progress_dialog.set_step_progress(@packet_log_reader.bytes_read / file_size)
+                end
+                @tabbed_plots_config.process_packet(packet)
+                packet_count += 1
+              end
+              progress_dialog.set_step_progress(1.0) if progress_dialog and not @cancel
+              progress_dialog.set_overall_progress(log_file_count.to_f / log_files.length.to_f) if progress_dialog and not @cancel
+            rescue Exception => error
+              @errors << error
+              progress_dialog.append_text("Error processing #{log_file}:\n#{error.class} : #{error.message}\n#{error.backtrace.join("\n")}\n", 2) if progress_dialog
+              # If a progress dialog is shown we can't just bail on this error or
+              # it will close and the user will have no idea what happened
+              # Thus we'll spin here waiting for them to close the dialog
+              if progress_dialog
+                sleep(0.1) until progress_dialog.complete?
+              end
+              break # Bail out because something bad happened
+            end
+            log_file_count += 1
+          end
+        ensure
+          progress_dialog.complete if progress_dialog
+          sleep(0.1) # Give the user a chance to see something if we process really fast
+          @done = true
+        end
+      end
+    end # def initialize
+
+    # Indicates if processing is complete
+    def done?
+      @done
+    end
+
+    # Kills the log file processing thread
+    def kill(progress_dialog = nil)
+      @cancel = true
+      @thread.kill
+      @thread = nil
+      @done = true
+      return true, false
+    end # def kill
+
+  end # class TabbedPlotsLogfileThread
+
+end # module Cosmos