Merge pull request #2 from UWCubeSat/noise-filter

Noise filter + reorganize placeholders

Author: refact0r

.clang-format

@@ -4,3 +4,7 @@ TabWidth: 4
 AccessModifierOffset: -3
 UseTab: Never
 SortIncludes: Never
+ColumnLimit: 120
+AllowShortFunctionsOnASingleLine: Empty
+PointerAlignment: Right
+BreakConstructorInitializers: AfterColon

src/scope/algorithms-placeholder/algorithms-placeholder.cpp

@@ -1,41 +1,42 @@
 #include "scope/command-line/execution/executors.hpp"
-#include "scope/common/style.hpp"
-#include "common/logging.hpp"
-#include "common/time/time.hpp"
 
+#include <cstring>
+
+#include <iostream>
 #include <memory>
 #include <utility>
-#include <cstring>
+#include <vector>
 
-namespace scope {
+#include "scope/common/style.hpp"
+#include "common/logging.hpp"
+#include "common/time/time.hpp"
 
-using Image = found::Image;
+namespace scope {
 
-PrimaryScopePipelineExecutor::PrimaryScopePipelineExecutor(RecalibrationOptions &&options,
-                                                           std::unique_ptr<NoiseFilterAlgorithm> noiseFilterAlgorithm,
-                                                           std::unique_ptr<StarCentroidAlgorithm> starCentroidAlgorithm,
-                                                           std::unique_ptr<OptimizationAlgorithm> optimizationAlgorithm)
-                                                           : options_(std::move(options)) {
+PrimaryScopePipelineExecutor::PrimaryScopePipelineExecutor(
+    RecalibrationOptions &&options, std::unique_ptr<NoiseFilterAlgorithm> noiseFilterAlgorithm,
+    std::unique_ptr<StarCentroidAlgorithm> starCentroidAlgorithm,
+    std::unique_ptr<OptimizationAlgorithm> optimizationAlgorithm) :
+    options_(std::move(options)) {
     // TODO: change inputs + outputs of stages to actual values we will use
     std::unique_ptr<found::FunctionStage<Images, Image>> noiseFilterStage(std::move(noiseFilterAlgorithm));
-    std::unique_ptr<found::FunctionStage<Image, std::vector<float>>> starCentroidStage(std::move(starCentroidAlgorithm));
-    std::unique_ptr<found::FunctionStage<std::vector<float>, std::vector<float>>> optimizationStage(std::move(optimizationAlgorithm));
+    std::unique_ptr<found::FunctionStage<Image, std::vector<float>>> starCentroidStage(
+        std::move(starCentroidAlgorithm));
+    std::unique_ptr<found::FunctionStage<std::vector<float>, std::vector<float>>> optimizationStage(
+        std::move(optimizationAlgorithm));
     this->pipeline_.AddStage(std::move(noiseFilterStage))
-                   .AddStage(std::move(starCentroidStage))
-                   .Complete(std::move(optimizationStage));
+        .AddStage(std::move(starCentroidStage))
+        .Complete(std::move(optimizationStage));
 }
 
 void PrimaryScopePipelineExecutor::ExecutePipeline() {
-    // Results are stored within the pipeline, can also be accessed
-    // via this function call
     this->pipeline_.Run(this->options_.images);
 }
 
-// Will output the values found by this recalibration
 void PrimaryScopePipelineExecutor::OutputResults() {
-    //std::vector<float> *&output = this->pipeline_.GetProduct();    
+    // std::vector<float> *&output = this->pipeline_.GetProduct();
     // TODO: something with output
     std::cout << "Nothing is implemented :(" << std::endl;
 }
 
-} // namespace scope
+}  // namespace scope

src/scope/algorithms-placeholder/algorithms-placeholder.hpp

@@ -1,34 +1,54 @@
+/**
+ * @file executors.hpp
+ * @brief Pipeline executor for the primary SCOPE calibration chain.
+ */
+
 #ifndef SRC_SCOPE_COMMAND_LINE_EXECUTION_EXECUTORS_HPP_
 #define SRC_SCOPE_COMMAND_LINE_EXECUTION_EXECUTORS_HPP_
 
 #include <memory>
 
 #include "scope/command-line/parsing/options.hpp"
 #include "scope/common/style.hpp"
-#include "scope/algorithms-placeholder/algorithms-placeholder.hpp"
+#include "scope/noise-filter/noise-filter.hpp"
+#include "scope/optimization/optimization.hpp"
+#include "scope/star-centroid/star-centroid.hpp"
 
 #include "command-line/execution/executors.hpp"
 
 namespace scope {
 
+/**
+ * Owns and runs the primary SCOPE calibration pipeline
+ * (noise filter -> star centroid -> optimization).
+ */
 class PrimaryScopePipelineExecutor : public found::PipelineExecutor {
-  public:
-    explicit PrimaryScopePipelineExecutor(
-        RecalibrationOptions &&options,
-        std::unique_ptr<NoiseFilterAlgorithm> noiseFilterAlgorithm,
-        std::unique_ptr<StarCentroidAlgorithm> starCentroidAlgorithm,
-        std::unique_ptr<OptimizationAlgorithm> optimizationAlgorithm);
-
+ public:
+    /**
+     * Constructs a PrimaryScopePipelineExecutor and assembles its pipeline.
+     *
+     * @param options Parsed recalibration options consumed by the run.
+     * @param noiseFilterAlgorithm Stage that reduces raw frames to one image.
+     * @param starCentroidAlgorithm Stage that extracts star centroids.
+     * @param optimizationAlgorithm Stage that fits camera parameters.
+     */
+    explicit PrimaryScopePipelineExecutor(RecalibrationOptions &&options,
+                                          std::unique_ptr<NoiseFilterAlgorithm> noiseFilterAlgorithm,
+                                          std::unique_ptr<StarCentroidAlgorithm> starCentroidAlgorithm,
+                                          std::unique_ptr<OptimizationAlgorithm> optimizationAlgorithm);
+
+    /// Runs the assembled pipeline end-to-end.
     void ExecutePipeline() override;
+    /// Prints the calibrated parameters produced by the pipeline.
     void OutputResults() override;
 
-  private:
-    // The options being used by the pipeline
+ private:
+    /// The options driving this pipeline run.
     const RecalibrationOptions options_;
-    // The primary pipeline for SCOPE operation
+    /// The pipeline assembled for SCOPE operation.
     PrimaryScopePipeline pipeline_;
 };
 
-} // namespace scope
+}  // namespace scope
 
-#endif // SRC_SCOPE_COMMAND_LINE_EXECUTION_EXECUTORS_HPP_
+#endif  // SRC_SCOPE_COMMAND_LINE_EXECUTION_EXECUTORS_HPP_

src/scope/command-line/execution/executors.cpp

@@ -34,9 +34,7 @@ SCOPE_CLI_OPTION("input-images", scope::Images, images, {}, scope::strtoimages(o
 
 // NOLINTEND
 
-/**
- * Options object, contains all data requested from user to run all algorithms
- */
+/** Parsed CLI options driving a recalibration run. */
 class RecalibrationOptions {
  public:
 #define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg,  \

src/scope/command-line/execution/executors.hpp

@@ -24,12 +24,12 @@ int optind = 2;
 
 namespace scope {
 
-/// For macro processing
+/// Sentinel for options with no default value.
 const char kNoDefaultArgument = 0;
 
 RecalibrationOptions ParseRecalibrationOptions(int argc, char **argv) {
-    // Define an enum for each valid flag (command-line entry), which maps it
-    // from the name to an integer
+    // Each block below re-expands RECALIBRATE to derive a piece of getopt
+    // wiring from the option table in options.hpp.
     enum class ClientOption {
 #define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg,  \
                          ASSIGN, doc)                                          \
@@ -38,8 +38,6 @@ RecalibrationOptions ParseRecalibrationOptions(int argc, char **argv) {
 #undef SCOPE_CLI_OPTION
     };
 
-    // Define an array of options, which defines the traits pertaining to each
-    // expected command-line entry
     static option long_options[] = {
 #define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg,  \
                          ASSIGN, doc)                                          \
@@ -50,15 +48,10 @@ RecalibrationOptions ParseRecalibrationOptions(int argc, char **argv) {
 #undef SCOPE_CLI_OPTION
         {0}};
 
-    // Define our result, and iterator helpers
     RecalibrationOptions options;
     int index;
     int option;
 
-    // Iterates through the list of command-line tokens and figures out
-    // what data to assign to which field in options. Note that the
-    // SCOPE_CLI_OPTION defines the conversion already between any
-    // particular parameter (as a string) to its actual type
     while ((option = getopt_long(argc, argv, "", long_options, &index)) != -1) {
         switch (option) {
 #define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg,  \
@@ -78,4 +71,4 @@ RecalibrationOptions ParseRecalibrationOptions(int argc, char **argv) {
     return options;
 }
 
-} // namespace scope
+}  // namespace scope

src/scope/command-line/parsing/options.hpp

@@ -8,14 +8,12 @@ namespace scope {
 #define HELP_MSG "Use ./scope --help or ./scope -h for help"
 
 /**
- * Parses the recalibration options from the command line to
- * run the recalibration algorithm
- * 
- * @param argc The number of command-line arguments
- * @param argv The command line arguments
- * 
- * @return CalibrationOptions The options for the calibration
- * algorithm as extracted on the command line
+ * Parses recalibration flags from the command line.
+ *
+ * @param argc The number of command-line arguments.
+ * @param argv The command-line arguments.
+ *
+ * @return The recalibration options extracted from the command line.
  */
 RecalibrationOptions ParseRecalibrationOptions(int argc, char **argv);
 

src/scope/command-line/parsing/parser.cpp

@@ -1,6 +1,7 @@
 #include <cstdlib>
 
 #include <iostream>
+#include <memory>
 #include <string>
 
 #include "scope/command-line/scope-main.hpp"

src/scope/command-line/parsing/parser.hpp

@@ -4,17 +4,13 @@
 namespace scope {
 
 /**
- * This is where the program starts.
+ * Program entry point. Parses command-line options and runs the
+ * recalibration pipeline.
  *
- * @param argc The number of arguments passed into the command line
- * @param argv The arguments passed into the command line
+ * @param argc The number of command-line arguments.
+ * @param argv The command-line arguments.
  *
- * @return An integer indicating success (0) iff the program executes
- * successfully
- *
- * @note The method itself uses command line arguments to generate
- * an Options object that represents all the algorithms we want to run
- * and their parameters
+ * @return 0 on success, non-zero on failure.
  */
 int main(int argc, char** argv);