DynaSlum/satsense

View on GitHub

Showing 13 of 64 total issues

File image.py has 337 lines of code (exceeds 250 allowed). Consider refactoring.
Open

"""Methods for loading images."""

import logging
import os
import time
Severity: Minor
Found in satsense/image.py - About 4 hrs to fix

    File rid.py has 325 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    import logging
    import math
    import pickle
    import sys
    from enum import Enum
    Severity: Minor
    Found in satsense/features/rid.py - About 3 hrs to fix

      Function from_file has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

          def from_file(cls, feature, filename_prefix):
              """Restore saved features."""
              new = cls(feature, None)
              for window in feature.windows:
                  for ext in ('nc', 'tif'):
      Severity: Minor
      Found in satsense/image.py - About 1 hr to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function _get_normalization_limits has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
      Open

          def _get_normalization_limits(self, band, image=None):
              """Return normalization limits for band."""
              if band not in self.normalization:
                  # select only non-masked values for computing scale
                  if image is None:
      Severity: Minor
      Found in satsense/image.py - About 1 hr to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function extract_feature has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

      def extract_feature(feature, generator):
          """Compute a feature vector."""
          logger.info("Computing feature %s with windows %s and arguments %s",
                      feature.__class__.__name__, feature.windows, feature.kwargs)
          if not generator.loaded_itype == feature.base_image:
      Severity: Minor
      Found in satsense/extract.py - About 1 hr to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function show_multipolygon has 7 arguments (exceeds 4 allowed). Consider refactoring.
      Open

      def show_multipolygon(multipolygon, axis, show_coords, extent, color, alpha,
      Severity: Major
      Found in satsense/util/shapefile.py - About 50 mins to fix

        Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
        Open

            def __init__(self,
        Severity: Minor
        Found in satsense/image.py - About 45 mins to fix

          Function from_images has 5 arguments (exceeds 4 allowed). Consider refactoring.
          Open

              def from_images(cls,
          Severity: Minor
          Found in satsense/features/sift.py - About 35 mins to fix

            Function from_images has 5 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                def from_images(cls,
            Severity: Minor
            Found in satsense/features/texton.py - About 35 mins to fix

              Function __iter__ has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
              Open

                  def __iter__(self):
                      if self._image_cache is None:
                          raise RuntimeError("Please load an image first using load_image.")
                      for i in range(self.shape[0]):
                          for j in range(self.shape[1]):
              Severity: Minor
              Found in satsense/generators.py - About 35 mins to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function __init__ has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
              Open

                  def __init__(self, windows=((25, 25), ), box_sizes=(10, 20, 30)):
                      # Check input
                      for window in windows:
                          for box_size in box_sizes:
                              if window[0] <= box_size or window[1] <= box_size:
              Severity: Minor
              Found in satsense/features/lacunarity.py - About 35 mins to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function __getitem__ has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
              Open

                  def __getitem__(self, itype):
                      """Get image of type."""
                      if itype in self.cache:
                          return self.cache[itype]
              
              
              Severity: Minor
              Found in satsense/image.py - About 25 mins to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function create_texton_kernels has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
              Open

              def create_texton_kernels():
                  """Create filter bank kernels."""
                  kernels = []
                  angles = 8
                  thetas = np.linspace(0, np.pi, angles)
              Severity: Minor
              Found in satsense/features/texton.py - About 25 mins to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Severity
              Category
              Status
              Source
              Language