add the index calculation class at digital_image_processing and the hamming code algorithm at hashes (#1152)

* add the index calculation at difital_image_processing file

* make changes at index_calculation

* update the variables to self variables at functions

* update the word wrap in comments at index_calculation

* add the hamming code algorithm

* Wrap long lines

digital_image_processing/index_calculation.py

@@ -0,0 +1,571 @@
+# Author: João Gustavo A. Amorim
+# Author email: joaogustavoamorim@gmail.com
+# Coding date:  jan 2019
+# python/black: True
+
+# Imports
+import numpy as np
+
+# Class implemented to calculus the index
+class IndexCalculation:
+    """
+        # Class Summary
+                This algorithm consists in calculating vegetation indices, these indices 
+            can be used for precision agriculture for example (or remote sensing). There are
+            functions to define the data and to calculate the implemented indices.
+
+        # Vegetation index
+            https://en.wikipedia.org/wiki/Vegetation_Index
+            A Vegetation Index (VI) is a spectral transformation of two or more bands designed 
+            to enhance the contribution of vegetation properties and allow reliable spatial and 
+            temporal inter-comparisons of terrestrial photosynthetic activity and canopy 
+            structural variations
+        
+        # Information about channels (Wavelength range for each)
+            * nir - near-infrared
+                https://www.malvernpanalytical.com/br/products/technology/near-infrared-spectroscopy
+                Wavelength Range 700 nm to 2500 nm
+            * Red Edge 
+                https://en.wikipedia.org/wiki/Red_edge
+                Wavelength Range 680 nm to 730 nm
+            * red
+                https://en.wikipedia.org/wiki/Color
+                Wavelength Range 635 nm to 700 nm
+            * blue
+                https://en.wikipedia.org/wiki/Color
+                Wavelength Range 450 nm to 490 nm
+            * green
+                https://en.wikipedia.org/wiki/Color
+                Wavelength Range 520 nm to 560 nm
+
+                
+        # Implemented index list
+                #"abbreviationOfIndexName" -- list of channels used
+
+                #"ARVI2"            --  red, nir
+                #"CCCI"             --  red, redEdge, nir
+                #"CVI"              --  red, green, nir
+                #"GLI"              --  red, green, blue
+                #"NDVI"             --  red, nir
+                #"BNDVI"            --  blue, nir
+                #"redEdgeNDVI"      --  red, redEdge
+                #"GNDVI"            --  green, nir
+                #"GBNDVI"           --  green, blue, nir
+                #"GRNDVI"           --  red, green, nir
+                #"RBNDVI"           --  red, blue, nir
+                #"PNDVI"            --  red, green, blue, nir
+                #"ATSAVI"           --  red, nir
+                #"BWDRVI"           --  blue, nir
+                #"CIgreen"          --  green, nir
+                #"CIrededge"        --  redEdge, nir
+                #"CI"               --  red, blue
+                #"CTVI"             --  red, nir
+                #"GDVI"             --  green, nir
+                #"EVI"              --  red, blue, nir
+                #"GEMI"             --  red, nir
+                #"GOSAVI"           --  green, nir
+                #"GSAVI"            --  green, nir
+                #"Hue"              --  red, green, blue
+                #"IVI"              --  red, nir
+                #"IPVI"             --  red, nir
+                #"I"                --  red, green, blue
+                #"RVI"              --  red, nir
+                #"MRVI"             --  red, nir
+                #"MSAVI"            --  red, nir
+                #"NormG"            --  red, green, nir
+                #"NormNIR"          --  red, green, nir
+                #"NormR"            --  red, green, nir
+                #"NGRDI"            --  red, green
+                #"RI"               --  red, green
+                #"S"                --  red, green, blue
+                #"IF"               --  red, green, blue
+                #"DVI"              --  red, nir
+                #"TVI"              --  red, nir
+                #"NDRE"               --  redEdge, nir
+
+        #list of all index implemented
+            #allIndex = ["ARVI2", "CCCI", "CVI", "GLI", "NDVI", "BNDVI", "redEdgeNDVI", "GNDVI", 
+                        "GBNDVI", "GRNDVI", "RBNDVI", "PNDVI", "ATSAVI", "BWDRVI", "CIgreen", 
+                        "CIrededge", "CI", "CTVI", "GDVI", "EVI", "GEMI", "GOSAVI", "GSAVI", 
+                        "Hue", "IVI", "IPVI", "I", "RVI", "MRVI", "MSAVI", "NormG", "NormNIR", 
+                        "NormR", "NGRDI", "RI", "S", "IF", "DVI", "TVI", "NDRE"]
+
+        #list of index with not blue channel
+            #notBlueIndex = ["ARVI2", "CCCI", "CVI", "NDVI", "redEdgeNDVI", "GNDVI", "GRNDVI", 
+                            "ATSAVI", "CIgreen", "CIrededge", "CTVI", "GDVI", "GEMI", "GOSAVI", 
+                            "GSAVI", "IVI", "IPVI", "RVI", "MRVI", "MSAVI", "NormG", "NormNIR", 
+                            "NormR", "NGRDI", "RI", "DVI", "TVI", "NDRE"]
+
+        #list of index just with RGB channels
+            #RGBIndex = ["GLI", "CI", "Hue", "I", "NGRDI", "RI", "S", "IF"]
+    """
+
+    def __init__(self, red=None, green=None, blue=None, redEdge=None, nir=None):
+        # print("Numpy version: " + np.__version__)
+        self.setMatrices(red=red, green=green, blue=blue, redEdge=redEdge, nir=nir)
+
+    def setMatrices(self, red=None, green=None, blue=None, redEdge=None, nir=None):
+        if red is not None:
+            self.red = red
+        if green is not None:
+            self.green = green
+        if blue is not None:
+            self.blue = blue
+        if redEdge is not None:
+            self.redEdge = redEdge
+        if nir is not None:
+            self.nir = nir
+        return True
+
+    def calculation(
+        self, index="", red=None, green=None, blue=None, redEdge=None, nir=None
+    ):
+        """
+            performs the calculation of the index with the values instantiated in the class
+            :str index: abbreviation of index name to perform
+        """
+        self.setMatrices(red=red, green=green, blue=blue, redEdge=redEdge, nir=nir)
+        funcs = {
+            "ARVI2": self.ARVI2,
+            "CCCI": self.CCCI,
+            "CVI": self.CVI,
+            "GLI": self.GLI,
+            "NDVI": self.NDVI,
+            "BNDVI": self.BNDVI,
+            "redEdgeNDVI": self.redEdgeNDVI,
+            "GNDVI": self.GNDVI,
+            "GBNDVI": self.GBNDVI,
+            "GRNDVI": self.GRNDVI,
+            "RBNDVI": self.RBNDVI,
+            "PNDVI": self.PNDVI,
+            "ATSAVI": self.ATSAVI,
+            "BWDRVI": self.BWDRVI,
+            "CIgreen": self.CIgreen,
+            "CIrededge": self.CIrededge,
+            "CI": self.CI,
+            "CTVI": self.CTVI,
+            "GDVI": self.GDVI,
+            "EVI": self.EVI,
+            "GEMI": self.GEMI,
+            "GOSAVI": self.GOSAVI,
+            "GSAVI": self.GSAVI,
+            "Hue": self.Hue,
+            "IVI": self.IVI,
+            "IPVI": self.IPVI,
+            "I": self.I,
+            "RVI": self.RVI,
+            "MRVI": self.MRVI,
+            "MSAVI": self.MSAVI,
+            "NormG": self.NormG,
+            "NormNIR": self.NormNIR,
+            "NormR": self.NormR,
+            "NGRDI": self.NGRDI,
+            "RI": self.RI,
+            "S": self.S,
+            "IF": self.IF,
+            "DVI": self.DVI,
+            "TVI": self.TVI,
+            "NDRE": self.NDRE,
+        }
+
+        try:
+            return funcs[index]()
+        except KeyError:
+            print("Index not in the list!")
+            return False
+
+    def ARVI2(self):
+        """
+            Atmospherically Resistant Vegetation Index 2
+            https://www.indexdatabase.de/db/i-single.php?id=396
+            :return: index
+             	−0.18+1.17*(self.nir−self.red)/(self.nir+self.red)
+        """
+        return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))
+
+    def CCCI(self):
+        """
+            Canopy Chlorophyll Content Index
+            https://www.indexdatabase.de/db/i-single.php?id=224
+            :return: index
+        """
+        return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
+            (self.nir - self.red) / (self.nir + self.red)
+        )
+
+    def CVI(self):
+        """
+            Chlorophyll vegetation index
+            https://www.indexdatabase.de/db/i-single.php?id=391
+            :return: index
+        """
+        return self.nir * (self.red / (self.green ** 2))
+
+    def GLI(self):
+        """
+            self.green leaf index
+            https://www.indexdatabase.de/db/i-single.php?id=375
+            :return: index
+        """
+        return (2 * self.green - self.red - self.blue) / (
+            2 * self.green + self.red + self.blue
+        )
+
+    def NDVI(self):
+        """
+                Normalized Difference self.nir/self.red Normalized Difference Vegetation Index, 
+            Calibrated NDVI - CDVI
+            https://www.indexdatabase.de/db/i-single.php?id=58
+            :return: index
+        """
+        return (self.nir - self.red) / (self.nir + self.red)
+
+    def BNDVI(self):
+        """
+                Normalized Difference self.nir/self.blue self.blue-normalized difference 
+            vegetation index
+            https://www.indexdatabase.de/db/i-single.php?id=135
+            :return: index
+        """
+        return (self.nir - self.blue) / (self.nir + self.blue)
+
+    def redEdgeNDVI(self):
+        """
+            Normalized Difference self.rededge/self.red
+            https://www.indexdatabase.de/db/i-single.php?id=235
+            :return: index
+        """
+        return (self.redEdge - self.red) / (self.redEdge + self.red)
+
+    def GNDVI(self):
+        """
+            Normalized Difference self.nir/self.green self.green NDVI
+            https://www.indexdatabase.de/db/i-single.php?id=401
+            :return: index
+        """
+        return (self.nir - self.green) / (self.nir + self.green)
+
+    def GBNDVI(self):
+        """
+            self.green-self.blue NDVI
+            https://www.indexdatabase.de/db/i-single.php?id=186
+            :return: index
+        """
+        return (self.nir - (self.green + self.blue)) / (
+            self.nir + (self.green + self.blue)
+        )
+
+    def GRNDVI(self):
+        """
+            self.green-self.red NDVI
+            https://www.indexdatabase.de/db/i-single.php?id=185
+            :return: index
+        """
+        return (self.nir - (self.green + self.red)) / (
+            self.nir + (self.green + self.red)
+        )
+
+    def RBNDVI(self):
+        """
+            self.red-self.blue NDVI
+            https://www.indexdatabase.de/db/i-single.php?id=187
+            :return: index
+        """
+        return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))
+
+    def PNDVI(self):
+        """
+            Pan NDVI
+            https://www.indexdatabase.de/db/i-single.php?id=188
+            :return: index
+        """
+        return (self.nir - (self.green + self.red + self.blue)) / (
+            self.nir + (self.green + self.red + self.blue)
+        )
+
+    def ATSAVI(self, X=0.08, a=1.22, b=0.03):
+        """
+            Adjusted transformed soil-adjusted VI
+            https://www.indexdatabase.de/db/i-single.php?id=209
+            :return: index
+        """
+        return a * (
+            (self.nir - a * self.red - b)
+            / (a * self.nir + self.red - a * b + X * (1 + a ** 2))
+        )
+
+    def BWDRVI(self):
+        """
+            self.blue-wide dynamic range vegetation index
+            https://www.indexdatabase.de/db/i-single.php?id=136
+            :return: index
+        """
+        return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)
+
+    def CIgreen(self):
+        """
+            Chlorophyll Index self.green
+            https://www.indexdatabase.de/db/i-single.php?id=128
+            :return: index
+        """
+        return (self.nir / self.green) - 1
+
+    def CIrededge(self):
+        """
+            Chlorophyll Index self.redEdge
+            https://www.indexdatabase.de/db/i-single.php?id=131
+            :return: index
+        """
+        return (self.nir / self.redEdge) - 1
+
+    def CI(self):
+        """
+            Coloration Index
+            https://www.indexdatabase.de/db/i-single.php?id=11
+            :return: index
+        """
+        return (self.red - self.blue) / self.red
+
+    def CTVI(self):
+        """
+            Corrected Transformed Vegetation Index
+            https://www.indexdatabase.de/db/i-single.php?id=244
+            :return: index
+        """
+        ndvi = self.NDVI()
+        return ((ndvi + 0.5) / (abs(ndvi + 0.5))) * (abs(ndvi + 0.5) ** (1 / 2))
+
+    def GDVI(self):
+        """
+            Difference self.nir/self.green self.green Difference Vegetation Index
+            https://www.indexdatabase.de/db/i-single.php?id=27
+            :return: index
+        """
+        return self.nir - self.green
+
+    def EVI(self):
+        """
+            Enhanced Vegetation Index
+            https://www.indexdatabase.de/db/i-single.php?id=16
+            :return: index
+        """
+        return 2.5 * (
+            (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
+        )
+
+    def GEMI(self):
+        """
+            Global Environment Monitoring Index
+            https://www.indexdatabase.de/db/i-single.php?id=25
+            :return: index
+        """
+        n = (2 * (self.nir ** 2 - self.red ** 2) + 1.5 * self.nir + 0.5 * self.red) / (
+            self.nir + self.red + 0.5
+        )
+        return n * (1 - 0.25 * n) - (self.red - 0.125) / (1 - self.red)
+
+    def GOSAVI(self, Y=0.16):
+        """
+            self.green Optimized Soil Adjusted Vegetation Index
+            https://www.indexdatabase.de/db/i-single.php?id=29
+            mit Y = 0,16
+            :return: index
+        """
+        return (self.nir - self.green) / (self.nir + self.green + Y)
+
+    def GSAVI(self, L=0.5):
+        """
+            self.green Soil Adjusted Vegetation Index
+            https://www.indexdatabase.de/db/i-single.php?id=31
+            mit L = 0,5
+            :return: index
+        """
+        return ((self.nir - self.green) / (self.nir + self.green + L)) * (1 + L)
+
+    def Hue(self):
+        """
+            Hue
+            https://www.indexdatabase.de/db/i-single.php?id=34
+            :return: index
+        """
+        return np.arctan(
+            (
+                ((2 * self.red - self.green - self.blue) / 30.5)
+                * (self.green - self.blue)
+            )
+        )
+
+    def IVI(self, a=None, b=None):
+        """
+            Ideal vegetation index
+            https://www.indexdatabase.de/db/i-single.php?id=276
+            b=intercept of vegetation line
+            a=soil line slope
+            :return: index
+        """
+        return (self.nir - b) / (a * self.red)
+
+    def IPVI(self):
+        """
+            Infraself.red percentage vegetation index
+            https://www.indexdatabase.de/db/i-single.php?id=35
+            :return: index
+        """
+        return (self.nir / ((self.nir + self.red) / 2)) * (self.NDVI() + 1)
+
+    def I(self):
+        """
+            Intensity
+            https://www.indexdatabase.de/db/i-single.php?id=36
+            :return: index
+        """
+        return (self.red + self.green + self.blue) / 30.5
+
+    def RVI(self):
+        """
+            Ratio-Vegetation-Index
+            http://www.seos-project.eu/modules/remotesensing/remotesensing-c03-s01-p01.html
+            :return: index
+        """
+        return self.nir / self.red
+
+    def MRVI(self):
+        """
+            Modified Normalized Difference Vegetation Index RVI
+            https://www.indexdatabase.de/db/i-single.php?id=275
+            :return: index
+        """
+        return (self.RVI() - 1) / (self.RVI() + 1)
+
+    def MSAVI(self):
+        """
+            Modified Soil Adjusted Vegetation Index
+            https://www.indexdatabase.de/db/i-single.php?id=44
+            :return: index
+        """
+        return (
+            (2 * self.nir + 1)
+            - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
+        ) / 2
+
+    def NormG(self):
+        """
+            Norm G
+            https://www.indexdatabase.de/db/i-single.php?id=50
+            :return: index
+        """
+        return self.green / (self.nir + self.red + self.green)
+
+    def NormNIR(self):
+        """
+            Norm self.nir
+            https://www.indexdatabase.de/db/i-single.php?id=51
+            :return: index
+        """
+        return self.nir / (self.nir + self.red + self.green)
+
+    def NormR(self):
+        """
+            Norm R
+            https://www.indexdatabase.de/db/i-single.php?id=52
+            :return: index
+        """
+        return self.red / (self.nir + self.red + self.green)
+
+    def NGRDI(self):
+        """
+                Normalized Difference self.green/self.red Normalized self.green self.red 
+            difference index, Visible Atmospherically Resistant Indices self.green (VIself.green)
+            https://www.indexdatabase.de/db/i-single.php?id=390
+            :return: index
+        """
+        return (self.green - self.red) / (self.green + self.red)
+
+    def RI(self):
+        """
+            Normalized Difference self.red/self.green self.redness Index
+            https://www.indexdatabase.de/db/i-single.php?id=74
+            :return: index
+        """
+        return (self.red - self.green) / (self.red + self.green)
+
+    def S(self):
+        """
+            Saturation
+            https://www.indexdatabase.de/db/i-single.php?id=77
+            :return: index
+        """
+        max = np.max([np.max(self.red), np.max(self.green), np.max(self.blue)])
+        min = np.min([np.min(self.red), np.min(self.green), np.min(self.blue)])
+        return (max - min) / max
+
+    def IF(self):
+        """
+            Shape Index
+            https://www.indexdatabase.de/db/i-single.php?id=79
+            :return: index
+        """
+        return (2 * self.red - self.green - self.blue) / (self.green - self.blue)
+
+    def DVI(self):
+        """
+                Simple Ratio self.nir/self.red Difference Vegetation Index, Vegetation Index 
+            Number (VIN)
+            https://www.indexdatabase.de/db/i-single.php?id=12
+            :return: index
+        """
+        return self.nir / self.red
+
+    def TVI(self):
+        """
+            Transformed Vegetation Index
+            https://www.indexdatabase.de/db/i-single.php?id=98
+            :return: index
+        """
+        return (self.NDVI() + 0.5) ** (1 / 2)
+
+    def NDRE(self):
+        return (self.nir - self.redEdge) / (self.nir + self.redEdge)
+
+
+"""
+# genering a random matrices to test this class
+red     = np.ones((1000,1000, 1),dtype="float64") * 46787
+green   = np.ones((1000,1000, 1),dtype="float64") * 23487
+blue    = np.ones((1000,1000, 1),dtype="float64") * 14578
+redEdge = np.ones((1000,1000, 1),dtype="float64") * 51045
+nir     = np.ones((1000,1000, 1),dtype="float64") * 52200
+
+# Examples of how to use the class
+
+# instantiating the class 
+cl = IndexCalculation()
+
+# instantiating the class with the values
+#cl = indexCalculation(red=red, green=green, blue=blue, redEdge=redEdge, nir=nir)
+
+# how set the values after instantiate the class cl, (for update the data or when dont 
+# instantiating the class with the values)
+cl.setMatrices(red=red, green=green, blue=blue, redEdge=redEdge, nir=nir)
+
+# calculating the indices for the instantiated values in the class
+    # Note: the CCCI index can be changed to any index implemented in the class.
+indexValue_form1    = cl.calculation("CCCI", red=red, green=green, blue=blue,
+                                     redEdge=redEdge, nir=nir).astype(np.float64)
+indexValue_form2    = cl.CCCI()
+
+# calculating the index with the values directly -- you can set just the values preferred -- 
+# note: the *calculation* fuction performs the function *setMatrices*
+indexValue_form3    = cl.calculation("CCCI", red=red, green=green, blue=blue,
+                                     redEdge=redEdge, nir=nir).astype(np.float64)
+
+print("Form 1: "+np.array2string(indexValue_form1, precision=20, separator=', ', floatmode='maxprec_equal'))
+print("Form 2: "+np.array2string(indexValue_form2, precision=20, separator=', ', floatmode='maxprec_equal'))
+print("Form 3: "+np.array2string(indexValue_form3, precision=20, separator=', ', floatmode='maxprec_equal'))
+
+# A list of examples results for different type of data at NDVI
+# float16 ->    0.31567383              #NDVI (red = 50, nir = 100)
+# float32 ->    0.31578946              #NDVI (red = 50, nir = 100)
+# float64 ->    0.3157894736842105      #NDVI (red = 50, nir = 100)
+# longdouble -> 0.3157894736842105      #NDVI (red = 50, nir = 100)
+"""

hashes/hamming_code.py

@@ -0,0 +1,315 @@
+# -*- coding: utf-8 -*-
+# Author: João Gustavo A. Amorim & Gabriel Kunz
+# Author email: joaogustavoamorim@gmail.com and gabriel-kunz@uergs.edu.br
+# Coding date:  apr 2019
+# Black: True
+
+"""
+    * This code implement the Hamming code:
+        https://en.wikipedia.org/wiki/Hamming_code - In telecommunication, 
+    Hamming codes are a family of linear error-correcting codes. Hamming
+    codes can detect up to two-bit errors or correct one-bit errors 
+    without detection of uncorrected errors. By contrast, the simple 
+    parity code cannot correct errors, and can detect only an odd number 
+    of bits in error. Hamming codes are perfect codes, that is, they 
+    achieve the highest possible rate for codes with their block length 
+    and minimum distance of three.
+
+    * the implemented code consists of:
+        * a function responsible for encoding the message (emitterConverter)
+            * return the encoded message
+        * a function responsible for decoding the message (receptorConverter)
+            * return the decoded message and a ack of data integrity
+    
+    * how to use:
+            to be used you must declare how many parity bits (sizePari) 
+        you want to include in the message.
+            it is desired (for test purposes) to select a bit to be set
+        as an error. This serves to check whether the code is working correctly.
+            Lastly, the variable of the message/word that must be desired to be 
+        encoded (text).
+    
+    * how this work:
+            declaration of variables (sizePari, be, text)
+
+            converts the message/word (text) to binary using the
+        text_to_bits function
+            encodes the message using the rules of hamming encoding
+            decodes the message using the rules of hamming encoding
+            print the original message, the encoded message and the
+        decoded message
+
+            forces an error in the coded text variable
+            decodes the message that was forced the error
+            print the original message, the encoded message, the bit changed
+        message and the decoded message
+"""
+
+# Imports
+import numpy as np
+
+# Functions of binary conversion--------------------------------------
+def text_to_bits(text, encoding="utf-8", errors="surrogatepass"):
+    """
+    >>> text_to_bits("msg")
+    '011011010111001101100111'
+    """
+    bits = bin(int.from_bytes(text.encode(encoding, errors), "big"))[2:]
+    return bits.zfill(8 * ((len(bits) + 7) // 8))
+
+
+def text_from_bits(bits, encoding="utf-8", errors="surrogatepass"):
+    """
+    >>> text_from_bits('011011010111001101100111')
+    'msg'
+    """
+    n = int(bits, 2)
+    return n.to_bytes((n.bit_length() + 7) // 8, "big").decode(encoding, errors) or "\0"
+
+
+# Functions of hamming code-------------------------------------------
+def emitterConverter(sizePar, data):
+    """
+    :param sizePar: how many parity bits the message must have
+    :param data:  information bits
+    :return: message to be transmitted by unreliable medium 
+            - bits of information merged with parity bits
+
+    >>> emitterConverter(4, "101010111111")
+    ['1', '1', '1', '1', '0', '1', '0', '0', '1', '0', '1', '1', '1', '1', '1', '1']
+    """
+    if sizePar + len(data) <= 2 ** sizePar - (len(data) - 1):
+        print("ERROR - size of parity don't match with size of data")
+        exit(0)
+
+    dataOut = []
+    parity = []
+    binPos = [bin(x)[2:] for x in range(1, sizePar + len(data) + 1)]
+    pos = [x for x in range(1, sizePar + len(data) + 1)]
+
+    # sorted information data for the size of the output data
+    dataOrd = []
+    # data position template + parity
+    dataOutGab = []
+    # parity bit counter
+    qtdBP = 0
+    # counter position of data bits
+    contData = 0
+
+    for x in range(1, sizePar + len(data) + 1):
+        # Performs a template of bit positions - who should be given,
+        # and who should be parity
+        if qtdBP < sizePar:
+            if ((np.log(x) / np.log(2))).is_integer():
+                dataOutGab.append("P")
+                qtdBP = qtdBP + 1
+            else:
+                dataOutGab.append("D")
+        else:
+            dataOutGab.append("D")
+
+        # Sorts the data to the new output size
+        if dataOutGab[-1] == "D":
+            dataOrd.append(data[contData])
+            contData += 1
+        else:
+            dataOrd.append(None)
+
+    # Calculates parity
+    qtdBP = 0  # parity bit counter
+    for bp in range(1, sizePar + 1):
+        # Bit counter one for a given parity
+        contBO = 0
+        # counter to control the loop reading
+        contLoop = 0
+        for x in dataOrd:
+            if x != None:
+                try:
+                    aux = (binPos[contLoop])[-1 * (bp)]
+                except:
+                    aux = "0"
+                if aux == "1":
+                    if x == "1":
+                        contBO += 1
+            contLoop += 1
+        if contBO % 2 == 0:
+            parity.append(0)
+        else:
+            parity.append(1)
+
+        qtdBP += 1
+
+    # Mount the message
+    ContBP = 0  # parity bit counter
+    for x in range(0, sizePar + len(data)):
+        if dataOrd[x] == None:
+            dataOut.append(str(parity[ContBP]))
+            ContBP += 1
+        else:
+            dataOut.append(dataOrd[x])
+
+    return dataOut
+
+
+def receptorConverter(sizePar, data):
+    """
+    >>> receptorConverter(4, "1111010010111111")
+    (['1', '0', '1', '0', '1', '0', '1', '1', '1', '1', '1', '1'], True)
+    """
+    # data position template + parity
+    dataOutGab = []
+    # Parity bit counter
+    qtdBP = 0
+    # Counter p data bit reading
+    contData = 0
+    # list of parity received
+    parityReceived = []
+    dataOutput = []
+
+    for x in range(1, len(data) + 1):
+        # Performs a template of bit positions - who should be given,
+        #  and who should be parity
+        if qtdBP < sizePar:
+            if ((np.log(x) / np.log(2))).is_integer():
+                dataOutGab.append("P")
+                qtdBP = qtdBP + 1
+            else:
+                dataOutGab.append("D")
+        else:
+            dataOutGab.append("D")
+
+        # Sorts the data to the new output size
+        if dataOutGab[-1] == "D":
+            dataOutput.append(data[contData])
+        else:
+            parityReceived.append(data[contData])
+        contData += 1
+
+    # -----------calculates the parity with the data
+    dataOut = []
+    parity = []
+    binPos = [bin(x)[2:] for x in range(1, sizePar + len(dataOutput) + 1)]
+    pos = [x for x in range(1, sizePar + len(dataOutput) + 1)]
+
+    #  sorted information data for the size of the output data
+    dataOrd = []
+    # Data position feedback + parity
+    dataOutGab = []
+    # Parity bit counter
+    qtdBP = 0
+    # Counter p data bit reading
+    contData = 0
+
+    for x in range(1, sizePar + len(dataOutput) + 1):
+        # Performs a template position of bits - who should be given,
+        # and who should be parity
+        if qtdBP < sizePar:
+            if ((np.log(x) / np.log(2))).is_integer():
+                dataOutGab.append("P")
+                qtdBP = qtdBP + 1
+            else:
+                dataOutGab.append("D")
+        else:
+            dataOutGab.append("D")
+
+        # Sorts the data to the new output size
+        if dataOutGab[-1] == "D":
+            dataOrd.append(dataOutput[contData])
+            contData += 1
+        else:
+            dataOrd.append(None)
+
+    # Calculates parity
+    qtdBP = 0  # parity bit counter
+    for bp in range(1, sizePar + 1):
+        # Bit counter one for a certain parity
+        contBO = 0
+        # Counter to control loop reading
+        contLoop = 0
+        for x in dataOrd:
+            if x != None:
+                try:
+                    aux = (binPos[contLoop])[-1 * (bp)]
+                except:
+                    aux = "0"
+                if aux == "1":
+                    if x == "1":
+                        contBO += 1
+            contLoop += 1
+        if contBO % 2 == 0:
+            parity.append("0")
+        else:
+            parity.append("1")
+
+        qtdBP += 1
+
+    # Mount the message
+    ContBP = 0  # Parity bit counter
+    for x in range(0, sizePar + len(dataOutput)):
+        if dataOrd[x] == None:
+            dataOut.append(str(parity[ContBP]))
+            ContBP += 1
+        else:
+            dataOut.append(dataOrd[x])
+
+    if parityReceived == parity:
+        ack = True
+    else:
+        ack = False
+
+    return dataOutput, ack
+
+
+# ---------------------------------------------------------------------
+"""
+# Example how to use
+
+# number of parity bits
+sizePari = 4
+
+# location of the bit that will be forced an error
+be = 2
+
+# Message/word to be encoded and decoded with hamming
+# text = input("Enter the word to be read: ")
+text = "Message01"
+
+# Convert the message to binary
+binaryText = text_to_bits(text)
+
+# Prints the binary of the string
+print("Text input in binary is '" + binaryText + "'")
+
+# total transmitted bits
+totalBits = len(binaryText) + sizePari
+print("Size of data is " + str(totalBits))
+
+print("\n --Message exchange--")
+print("Data to send ------------> " + binaryText)
+dataOut = emitterConverter(sizePari, binaryText)
+print("Data converted ----------> " + "".join(dataOut))
+dataReceiv, ack = receptorConverter(sizePari, dataOut)
+print(
+    "Data receive ------------> "
+    + "".join(dataReceiv)
+    + "\t\t -- Data integrity: "
+    + str(ack)
+)
+
+
+print("\n --Force error--")
+print("Data to send ------------> " + binaryText)
+dataOut = emitterConverter(sizePari, binaryText)
+print("Data converted ----------> " + "".join(dataOut))
+
+# forces error
+dataOut[-be] = "1" * (dataOut[-be] == "0") + "0" * (dataOut[-be] == "1")
+print("Data after transmission -> " + "".join(dataOut))
+dataReceiv, ack = receptorConverter(sizePari, dataOut)
+print(
+    "Data receive ------------> "
+    + "".join(dataReceiv)
+    + "\t\t -- Data integrity: "
+    + str(ack)
+)
+"""