Update clang-format rules and reformat sources

.clang-format

@@ -1,10 +1,27 @@
+---
 BasedOnStyle: Google
+
 IndentWidth: 4
-TabWidth: 4
 AccessModifierOffset: -3
-UseTab: Never
-SortIncludes: Never
 ColumnLimit: 120
-AllowShortFunctionsOnASingleLine: Empty
+
 PointerAlignment: Right
-BreakConstructorInitializers: AfterColon
+DerivePointerAlignment: false
+
+AllowShortBlocksOnASingleLine: Empty
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: WithoutElse
+
+BreakStringLiterals: false
+ReflowComments: false
+
+SpaceAfterTemplateKeyword: false
+
+SortIncludes: Never
+IncludeBlocks: Preserve
+
+AlignConsecutiveMacros: Consecutive
+
+BinPackParameters: false
+BinPackArguments: false
+...

.clang-format-ignore

@@ -0,0 +1 @@
+src/scope/command-line/parsing/options.hpp

.devcontainer/devcontainer.json

@@ -5,5 +5,22 @@
   "workspaceFolder": "/workspace",
   "overrideCommand": true,
   "postCreateCommand": "git config --global user.name \"${GIT_AUTHOR_NAME:-Your Name}\" && git config --global user.email \"${GIT_AUTHOR_EMAIL:-you@example.com}\" && /workspace/build.sh cmake",
-  "shutdownAction": "stopCompose"
+  "shutdownAction": "stopCompose",
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "twxs.cmake",
+        "ms-vscode.cpptools"
+      ],
+      "settings": {
+        "[cpp]": {
+          "editor.defaultFormatter": "ms-vscode.cpptools",
+          "editor.formatOnSave": true,
+          "editor.formatOnSaveMode": "modifications"
+        },
+        "C_Cpp.formatting": "clangFormat",
+        "C_Cpp.clang_format_style": "file"
+      }
+    }
+  }
 }

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

@@ -13,11 +13,11 @@
 
 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(

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

@@ -37,9 +37,7 @@ SCOPE_CLI_OPTION("input-images", scope::Images, images, {}, scope::strtoimages(o
 /** Parsed CLI options driving a recalibration run. */
 class RecalibrationOptions {
  public:
-#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg,  \
-                         ASSIGN, doc)                                          \
-    type prop = defaultVal;
+#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg, ASSIGN, doc) type prop = defaultVal;
     RECALIBRATE
 #undef SCOPE_CLI_OPTION
 };

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

@@ -8,18 +8,17 @@
 
 int optind = 2;
 
-#define OPTIONAL_OPTARG()                                                      \
-    ((optarg == NULL && optind < argc && argv[optind][0] != '-')               \
-         ? static_cast<bool>(optarg = argv[optind++])                          \
-         : (optarg != NULL))
+#define OPTIONAL_OPTARG()                                                                                     \
+    ((optarg == NULL && optind < argc && argv[optind][0] != '-') ? static_cast<bool>(optarg = argv[optind++]) \
+                                                                 : (optarg != NULL))
 
 #define REQ_ASSIGN(options, prop, value, default) options.prop = (value);
 
-#define OPT_ASSIGN(options, prop, value, default)                              \
-    if (OPTIONAL_OPTARG()) {                                                   \
-        options.prop = value;                                                  \
-    } else {                                                                   \
-        options.prop = default;                                                \
+#define OPT_ASSIGN(options, prop, value, default) \
+    if (OPTIONAL_OPTARG()) {                      \
+        options.prop = value;                     \
+    } else {                                      \
+        options.prop = default;                   \
     }
 
 namespace scope {
@@ -31,19 +30,17 @@ RecalibrationOptions ParseRecalibrationOptions(int argc, char **argv) {
     // 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)                                          \
-    prop,
+#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg, ASSIGN, doc) prop,
         RECALIBRATE
 #undef SCOPE_CLI_OPTION
     };
 
     static option long_options[] = {
-#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg,  \
-                         ASSIGN, doc)                                          \
-    {name,                                                                     \
-     defaultArg == kNoDefaultArgument ? required_argument : optional_argument, \
-     0, static_cast<int>(ClientOption::prop)},
+#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg, ASSIGN, doc) \
+    {name,                                                                                 \
+     defaultArg == kNoDefaultArgument ? required_argument : optional_argument,             \
+     0,                                                                                    \
+     static_cast<int>(ClientOption::prop)},
         RECALIBRATE
 #undef SCOPE_CLI_OPTION
         {0}};
@@ -54,17 +51,16 @@ RecalibrationOptions ParseRecalibrationOptions(int argc, char **argv) {
 
     while ((option = getopt_long(argc, argv, "", long_options, &index)) != -1) {
         switch (option) {
-#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg,  \
-                         ASSIGN, doc)                                          \
-    case static_cast<int>(ClientOption::prop):                                 \
-        ASSIGN(options, prop, converter, defaultArg)                           \
+#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg, ASSIGN, doc) \
+    case static_cast<int>(ClientOption::prop):                                             \
+        ASSIGN(options, prop, converter, defaultArg)                                       \
         break;
             RECALIBRATE
 #undef SCOPE_CLI_OPTION
-        default:
-            LOG_ERROR("Illegal flag detected. " << HELP_MSG);
-            exit(EXIT_FAILURE);
-            break;
+            default:
+                LOG_ERROR("Illegal flag detected. " << HELP_MSG);
+                exit(EXIT_FAILURE);
+                break;
         }
     }
 

src/scope/command-line/scope-main.cpp

@@ -15,18 +15,15 @@ namespace scope {
 namespace {
 
 void PrintHelp() {
-    std::cout << "Usage: ./scope <option> [[flag value]...] [[flag=value]...]"
-              << std::endl;
+    std::cout << "Usage: ./scope <option> [[flag value]...] [[flag=value]...]" << std::endl;
     std::cout << std::endl;
     std::cout << "Current capabilities:" << std::endl;
-    std::cout << "\tCalculates camera intrisic and distortion paramters."
-              << std::endl;
+    std::cout << "\tCalculates camera intrisic and distortion paramters." << std::endl;
     std::cout << std::endl;
-    std::cout << "==================== Calibration Flags ===================="
-              << std::endl;
+    std::cout << "==================== Calibration Flags ====================" << std::endl;
     std::cout << std::endl;
-#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg,  ASSIGN, doc)  \
-    std::cout << "\t--" << name << std::endl;  \
+#define SCOPE_CLI_OPTION(name, type, prop, defaultVal, converter, defaultArg, ASSIGN, doc) \
+    std::cout << "\t--" << name << std::endl;                                              \
     std::cout << "\t\t" << doc << std::endl;
     RECALIBRATE
 #undef SCOPE_CLI_OPTION
@@ -48,8 +45,7 @@ int main(int argc, char **argv) {
     }
 
     std::unique_ptr<found::PipelineExecutor> executor;
-    executor = CreatePrimaryScopePipelineExecutor(
-                       ParseRecalibrationOptions(argc, argv));
+    executor = CreatePrimaryScopePipelineExecutor(ParseRecalibrationOptions(argc, argv));
 
     executor->ExecutePipeline();
     executor->OutputResults();

src/scope/command-line/scope-main.hpp

@@ -12,7 +12,7 @@ namespace scope {
  *
  * @return 0 on success, non-zero on failure.
  */
-int main(int argc, char** argv);
+int main(int argc, char **argv);
 
 }  // namespace scope
 

src/scope/main.cpp

@@ -10,4 +10,6 @@
  * successfully
  *
  */
-int main(int argc, char** argv) { return scope::main(argc, argv); }
+int main(int argc, char **argv) {
+    return scope::main(argc, argv);
+}

src/scope/noise-filter/noise-filter.cpp

@@ -15,48 +15,41 @@ namespace {
 /// @param images Input images to validate.
 /// @throws std::invalid_argument if the image collection is empty.
 /// @throws std::runtime_error if any image is null or has mismatched dimensions.
-void ValidateInput(const Images& images) {
+void ValidateInput(const Images &images) {
     if (images.empty()) {
-        throw std::invalid_argument(
-            "DarkScreenFilter requires at least one image");
+        throw std::invalid_argument("DarkScreenFilter requires at least one image");
     }
 
-    const Image& reference = images.front();
+    const Image &reference = images.front();
     if (reference.image == nullptr) {
         throw std::runtime_error("Input image pointer is null");
     }
-    if (reference.width <= 0 || reference.height <= 0 ||
-        reference.channels <= 0) {
-        throw std::runtime_error(
-            "Input image dimensions/channels must be positive");
+    if (reference.width <= 0 || reference.height <= 0 || reference.channels <= 0) {
+        throw std::runtime_error("Input image dimensions/channels must be positive");
     }
 
     for (size_t i = 1; i < images.size(); ++i) {
-        const Image& image = images[i];
+        const Image &image = images[i];
         if (image.image == nullptr) {
             throw std::runtime_error("Input image pointer is null");
         }
-        if (image.width != reference.width ||
-            image.height != reference.height ||
+        if (image.width != reference.width || image.height != reference.height ||
             image.channels != reference.channels) {
-            throw std::runtime_error(
-                "All images must share width, height, and channels");
+            throw std::runtime_error("All images must share width, height, and channels");
         }
     }
 }
 
 }  // namespace
 
-Image DarkScreenFilter::Run(const Images& images) {
+Image DarkScreenFilter::Run(const Images &images) {
     ValidateInput(images);
 
-    const Image& reference = images.front();
-    const size_t valueCount = static_cast<size_t>(reference.width) *
-                              static_cast<size_t>(reference.height) *
+    const Image &reference = images.front();
+    const size_t valueCount = static_cast<size_t>(reference.width) * static_cast<size_t>(reference.height) *
                               static_cast<size_t>(reference.channels);
 
-    unsigned char* buffer =
-        static_cast<unsigned char*>(std::malloc(valueCount));
+    unsigned char *buffer = static_cast<unsigned char *>(std::malloc(valueCount));
     if (buffer == nullptr) {
         throw std::bad_alloc();
     }
@@ -69,10 +62,7 @@ Image DarkScreenFilter::Run(const Images& images) {
             samples[j] = images[j].image[i];
         }
 
-        std::nth_element(
-            samples.begin(),
-            samples.begin() + static_cast<std::ptrdiff_t>(medianIndex),
-            samples.end());
+        std::nth_element(samples.begin(), samples.begin() + static_cast<std::ptrdiff_t>(medianIndex), samples.end());
         buffer[i] = samples[medianIndex];
     }
 

src/scope/providers/factory.hpp

@@ -18,19 +18,16 @@ namespace scope {
  * @return The assembled PrimaryScopePipelineExecutor.
  */
 inline std::unique_ptr<PrimaryScopePipelineExecutor> CreatePrimaryScopePipelineExecutor(
-        RecalibrationOptions &&options) {
-    std::unique_ptr<NoiseFilterAlgorithm> noiseAlg = ProvideNoiseFilterAlgorithm(
-                                                       std::forward<const RecalibrationOptions&&>(options));
-    std::unique_ptr<StarCentroidAlgorithm> starAlg = ProvideStarCentroidAlgorithm(
-                                                       std::forward<const RecalibrationOptions&&>(options));
-    std::unique_ptr<OptimizationAlgorithm> optAlg = ProvideOptimizationAlgorithm(
-                                                       std::forward<const RecalibrationOptions&&>(options));
+    RecalibrationOptions &&options) {
+    std::unique_ptr<NoiseFilterAlgorithm> noiseAlg =
+        ProvideNoiseFilterAlgorithm(std::forward<const RecalibrationOptions &&>(options));
+    std::unique_ptr<StarCentroidAlgorithm> starAlg =
+        ProvideStarCentroidAlgorithm(std::forward<const RecalibrationOptions &&>(options));
+    std::unique_ptr<OptimizationAlgorithm> optAlg =
+        ProvideOptimizationAlgorithm(std::forward<const RecalibrationOptions &&>(options));
 
     return std::make_unique<PrimaryScopePipelineExecutor>(
-        std::move(options),
-        std::move(noiseAlg),
-        std::move(starAlg),
-        std::move(optAlg));
+        std::move(options), std::move(noiseAlg), std::move(starAlg), std::move(optAlg));
 }
 
 }  // namespace scope