Count PixelsHow the function inRange() is used, pixels can be counted with the function countNonZero().Then the amount of pixels obtained in each inRange can be obtained as follows:pixelsAsfalto = cv2.countNonZero(somenteAsfalto) pixelsTerra = cv2.countNonZero(somenteTerra) pixelsVerde = cv2.countNonZero(somenteVerde) And the total amount of pixels of the image:pixelsTotal = img.size By splitting each amount of pixels by the total amount, you get the percentage.CodeThen the code would be as follows:import cv2 import numpy as np import matplotlib.pyplot as plt def mostrar_inRange(img, mask): imask = mask > 0 sliced = np.zeros_like(img, np.uint8) sliced[imask] = img[imask] plt.subplot(211) plt.imshow(sliced) plt.subplot(212) plt.imshow(img) plt.show() img = cv2.imread("IF23-1-2018.jpg") gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ret, imgThresh = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY) somenteAsfalto = cv2.inRange(img, asfaltoMax, asfaltoMin) somenteTerra = cv2.inRange(img, terraMax, terraMin) somenteVerde = cv2.inRange(img, verdeMax, verdeMin) pixelsAsfalto = cv2.countNonZero(somenteAsfalto) pixelsTerra = cv2.countNonZero(somenteTerra) pixelsVerde = cv2.countNonZero(somenteVerde) pixelsTotal = img.size mostrar_inRange(img, somenteAsfalto) mostrar_inRange(img, somenteTerra) mostrar_inRange(img, somenteVerde) print('% Asfalto: ', (pixelsAsfalto/pixelsTotal)*100) print('% Terra: ', (pixelsTerra /pixelsTotal)*100) print('% Verde: ', (pixelsVerde/pixelsTotal)*100) Note: The color segmentation on gray scale is not the best option, as the image is colored the best would be to realize this in the HSV color space. But the quality of the image is also not of the best and the color of the asphalt is very similar to the roof of the houses... Then segmentation should be refined in other ways, in addition to the use of color segmentation. An alternative to finding the asphalt would be to limit the search range with the use of Hough Lines.

Images in OpenCV are arrays, you are forgetting to use the array indices to catch the color #auxCor em B, G, R auxCor = imgThresh[i, j] I don't know if your work is just an exercise, but you can use the function https://docs.opencv.org/4.0.1/d2/de8/group__core__array.html#ga48af0ab51e36436c5d04340e036ce981 of opencv to know if a color is within certain rangeEdit: Updating the answer. The threshold returns 2 values (a retval and the binary image). In the line of the threshold vc should ignore the retval to take only the image:_, imgThresh = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY) Edit2: The inRange eh in the whole image, if you will use it, you do not need the threshold:asfaltoMax = np.array([108, 109, 111]) asfaltoMin = np.array([175, 175, 175]) terraMax = np.array([33, 62, 123]) terraMin = np.array([163, 169, 206]) img = cv2.imread("IF24-6-2015.jpg") somenteAsfalto = cv2.inRange(img, asfaltoMin, asfaltoMax) somenteTerra = cv2.inRange(img, terraMin, terraMax) for i in range(img.shape[0]): for j in range(img.shape[1]): if somenteAsfalto[i, j] == 1: print ("tem asfalto em %d - %d" % (i, j))

After conversion to gray, you lose all color information BGR. Then it is not possible to carry out the conversion of gray to color.What happens when you convert from gray scale For BGR with cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) is the creation of 3 channels, but all with equal values. It was on a gray scale.ExampleA pixel that has the following grayscale value: (127), after conversion it will have three channels: (127, 127, 127)AlternativeAn alternative to solving this problem is to save a copy of the original image with: copia = img.copy()And after finding the coordinates in gray scale, work on the original image.ObservationThe standard OpenCV color space is BGR, then when loading the image with img = cv2.imread(IMG+'.png'), it is in the color space BGR.Then the conversion gray = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY) should be gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

OpenCV works with this (or with variants of it) algorithm. Sparse optical flow: These algorithms, like the Kanade-Lucas-Tomashi (KLT) feature tracker, track the location of a few feature points in an image.The example creates a simple app that tracks some points in a video. To decide the point is used the function cv.goodFeaturesToTrack(), Take the first frame, some points (in the corners) are detected with the Shi-Tomasi Corner Detector function, so these points are traced iteratively through the optic flow Lucas-Kanade. The frame and previous points, and the next frame are passed to the function cv.calcOpticalFlowPyrLK(). The return the next points and some status numbers that can be 1 if the next point is found, otherwise zero.See the code:import numpy as np import cv2 as cv cap = cv.VideoCapture('slow.flv') # params for ShiTomasi corner detection feature_params = dict( maxCorners = 100, qualityLevel = 0.3, minDistance = 7, blockSize = 7 ) # Parameters for lucas kanade optical flow lk_params = dict( winSize = (15,15), maxLevel = 2, criteria = (cv.TERM_CRITERIA_EPS | cv.TERM_CRITERIA_COUNT, 10, 0.03)) # Create some random colors color = np.random.randint(0,255,(100,3)) # Take first frame and find corners in it ret, old_frame = cap.read() old_gray = cv.cvtColor(old_frame, cv.COLOR_BGR2GRAY) p0 = cv.goodFeaturesToTrack(old_gray, mask = None, **feature_params) # Create a mask image for drawing purposes mask = np.zeros_like(old_frame) while(1): ret,frame = cap.read() frame_gray = cv.cvtColor(frame, cv.COLOR_BGR2GRAY) # calculate optical flow p1, st, err = cv.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params) # Select good points good_new = p1[st==1] good_old = p0[st==1] # draw the tracks for i,(new,old) in enumerate(zip(good_new,good_old)): a,b = new.ravel() c,d = old.ravel() mask = cv.line(mask, (a,b),(c,d), color[i].tolist(), 2) frame = cv.circle(frame,(a,b),5,color[i].tolist(),-1) img = cv.add(frame,mask) cv.imshow('frame',img) k = cv.waitKey(30) & 0xff if k == 27: break # Now update the previous frame and previous points old_gray = frame_gray.copy() p0 = good_new.reshape(-1,1,2) cv.destroyAllWindows() cap.release() Result: Source: https://docs.opencv.org/3.4/d7/d8b/tutorial_py_lucas_kanade.html

ResultsThe image of the left is the original one and the one of the right one without reflection. Codeimport cv2 import numpy as np import urllib.request resp = urllib.request.urlopen("https://i.stack.imgur.com/TvChy.jpg") img = np.asarray(bytearray(resp.read()), dtype="uint8") img = cv2.imdecode(img, cv2.IMREAD_COLOR) copia = img.copy() #Converte para Escala de Cinza gray = cv2.cvtColor(copia,cv2.COLOR_BGR2GRAY) #Máscara para obter o que está no intervalo branco mask = cv2.inRange(gray, 215, 255) #Lógica AND mask_not = cv2.bitwise_not(mask) copia = cv2.bitwise_and(copia, copia, mask=mask_not ) #Interpolação da imagem para preencher os vazios inpaint = cv2.inpaint(copia, mask, 3,cv2.INPAINT_TELEA) #Mostra a nova imagem e a original cv2.imshow("Original / Inpaint", np.hstack([img, inpaint])) cv2.waitKey(0) ExplanationUpload the image and convert to grayscale (gray)Creates an image mask, with values between range 215 and 255 (next to white)Uses the AND logic to remove the pixels from the image between the range set in the mask maskFill in empty spaces with interpolation Inpaint by Alexandru Telea, predicting what should be in that empty placeA fine tuning can probably be done in the parameters InRange: mask = cv2.inRange(gray, 215, 255)

The error is very descriptive, you are taking a tuple and trying to split by 2. You can only split a number, not a dataset.The documentation is quite flawed, but in the end I managed to find that the variable img.shape is getting even a tuple with some image data. You can't take that tuple, but you can deconstruct it into variables and then take one of these variables and make the split if any of the elements is a number, and in fact I managed to infer it is. So to get the width should have done this:_, width, _ = img.shape https://github.com/maniero/SOpt/blob/master/Python/Syntax/MultiAssign.py .Even if I don't need the other elements I need to pick them up, in case I used _ to discard them and not to create a variable to the log.

If you are already using morphological operations, why not directly use a closure to eliminate the hair?You will need to know about their average grossness for the generation of the structuring element, or you can leave this configurable value on your system. In all ways, I suggest using a cross instead of a rectangle because it eliminates the hair while maintaining a greater connection of "syms" between the paints (in the later result of the threshold).In fact, I'm assuming your interest is to detect the areas of paints, so it also includes a simple example of thresholding (thresholding). I'm using the average value of the grayscale (127), but you may need to make a fine adjustment depending on your images.Here is the code (read your own disk image, called test. png here in my example):import numpy as np import matplotlib.pyplot as plt import cv2 pic = cv2.imread('teste.png') img2gray = cv2.cvtColor(pic, cv2.COLOR_RGB2GRAY) Remove hair with closing and blur kernel = cv2.getStructuringElement(cv2.MORPH_CROSS,(10,10)) closing = cv2.morphologyEx(img2gray, cv2.MORPH_CLOSE, kernel) closing = cv2.GaussianBlur(closing, (5, 5), 0) Thresholding for the skin patches _,threshold = cv2.threshold(closing, 127, 255, cv2.THRESH_BINARY) fig = plt.figure('Deteção de Pintas') plt.subplot(131) plt.title('Imagem original') plt.imshow(img2gray, cmap='gray') plt.subplot(132) plt.title('Resultado do Fechamento') plt.imshow(closing, cmap='gray') plt.subplot(133) plt.title('Resultado da Limiarização') plt.imshow(threshold, cmap='gray') plt.show() And the result: P.S.: If the threshold result is not good enough (even if it is to be used as a mask), you can try a different approach with KMédias: https://docs.opencv.org/3.4.3/d1/d5c/tutorial_py_kmeans_opencv.html Use 3 (or 4) clusters, for example, and throw out only the pixels of the clearest cluster, keeping the original pixels from the other two darker clusters.

O Canny Edge the way it is being implemented is leaving a pupil very small and similar to the noises created by the eyelashes.I think the slice of black color is the best option to extract the pupil, then use the Detection of circlesDetects pupil circle with Hough Circles Region of Interest and Grab CutCreates the region of interest (ROI) with the coordinates of the found circle and uses the Grab Cut to extract the pupil Codeimport cv2 import numpy as np import urllib.request resp = urllib.request.urlopen("https://i.stack.imgur.com/NL10Y.jpg") img = np.asarray(bytearray(resp.read()), dtype="uint8") img = cv2.imdecode(img, cv2.IMREAD_COLOR) copia = img.copy() Extrai as cores entre o intervalo BGR definido mask = cv2.inRange(img, (0, 0, 0), (60, 60, 60)) slice no preto imask = mask > 0 preto = np.zeros_like(img, np.uint8) preto[imask] = img[imask] preto = cv2.cvtColor(preto, cv2.COLOR_BGR2GRAY) cv2.imshow('Preto', preto) detecção de círculos circles = cv2.HoughCircles(preto, cv2.HOUGH_GRADIENT, 1, 100, param1=30, param2=30, minRadius=20, maxRadius=100) #param do Grab Cut bgdModel = np.zeros((1, 65), np.float64) fgdModel = np.zeros((1, 65), np.float64) pelo menos um círculo encontrado if circles is not None: # converte para int circles = np.round(circles[0, :]).astype("int") # loop nas coordenadas (x, y) e raio dos círculos encontrados for (x, y, r) in circles: roi = img.copy() r=r+50 # Desenha o círculo encontrado cv2.circle(copia, (x, y), r - 25, (0, 255, 0), 4) # Desenha o retângulo do centro do círculo cv2.rectangle(copia, (x - 5, y - 5), (x + 5, y + 5), (0, 128, 255), -1) # Região de interesse com a pupila roi = roi[y-r:y+r, x-r:x+r] roi_x, roi_y, _ = roi.shape #Grab Cut da Pupila mask = np.zeros(roi.shape[:2], np.uint8) rect = (10, 10,roi_x-10, roi_y-10) cv2.grabCut(roi, mask, rect, bgdModel, fgdModel, 5, cv2.GC_INIT_WITH_RECT) mask2 = np.where((mask == 2) | (mask == 0), 0, 1).astype('uint8') roi_grab = roi * mask2[:, :, np.newaxis] # Mostra o Grab Cut cv2.imshow("Grab Cut", np.hstack([roi, roi_grab])) # Mostra a imagem com o círcuto e centro encontrado pelo Hough Circle cv2.imshow("output", np.hstack([img, copia])) cv2.waitKey(0)

DepthIt is the Data Type of each element of the image, i.e. the accuracy of each pixel. The more bits per pixel, the better the representation of color differences and intensities.On the other hand, this can give more complexity when creating a segmentation by Thresholding, because the color/intensity variation is greater too.Then the choice of depth depends on the desired application.Data TypesA https://docs.opencv.org/2.4/modules/core/doc/intro.html#fixed-pixel-types-limited-use-of-templates explains why you use these types of Data Types.In version 4.0.0-beta:8-bit unsigned integer (uchar)8-bit signed integer (schar)16-bit unsigned integer (ushort)16-bit signed integer (short)16-bit floating-point number (float)32-bit signed integer (int)32-bit floating-point number (float)64-bit floating-point number (double)No https://github.com/opencv/opencv/blob/master/modules/core/include/opencv2/core/traits.hpp you can find the Data Types of depth in the following code:/** @brief A helper class for cv::DataType The class is specialized for each fundamental numerical data type supported by OpenCV. It provides DataDepth<T>::value constant. */ template<typename _Tp> class DataDepth { public: enum { value = DataType<_Tp>::depth, fmt = DataType<_Tp>::fmt }; }; #ifdef OPENCV_TRAITS_ENABLE_DEPRECATED template<int _depth> class TypeDepth { #ifdef OPENCV_TRAITS_ENABLE_LEGACY_DEFAULTS enum { depth = CV_USRTYPE1 }; typedef void value_type; #endif }; template<> class TypeDepth<CV_8U> { enum { depth = CV_8U }; typedef uchar value_type; }; template<> class TypeDepth<CV_8S> { enum { depth = CV_8S }; typedef schar value_type; }; template<> class TypeDepth<CV_16U> { enum { depth = CV_16U }; typedef ushort value_type; }; template<> class TypeDepth<CV_16S> { enum { depth = CV_16S }; typedef short value_type; }; template<> class TypeDepth<CV_32S> { enum { depth = CV_32S }; typedef int value_type; }; template<> class TypeDepth<CV_32F> { enum { depth = CV_32F }; typedef float value_type; }; template<> class TypeDepth<CV_64F> { enum { depth = CV_64F }; typedef double value_type; }; template<> class TypeDepth<CV_16F> { enum { depth = CV_16F }; typedef float16_t value_type; }; #endif //! @} Depending on the version of OpenCV are 7 Data Types, plus the legacy Data Type CV_USRTYPE1Or are 8 Data Types from version 4.x, with the addition of the new https://github.com/opencv/opencv/commit/6d7f5871dbf9e1e9082c6a99f5358e413e844b80 PythonIn OpenCV 3.4.3 and Python 3.x some attributes can be obtained with [(i,type(getattr(cv2,i))) for i in dir(cv2)]And the list of data types of depth:import cv2 import re depths = [i for i in dir(cv2) if re.search('^CV_(?:\d+[A-Z]{1}|USRTYPE1)$', i, re.IGNORECASE)] print(depths) Which returns: ['CV_16S', 'CV_16U', 'CV_32F', 'CV_32S', 'CV_64F', 'CV_8S', 'CV_8U']Note that depth and type http://answers.opencv.org/question/742/matrix-depth-equals-0/#747 . Yeah. type is the combination of depth + number of channels.dddepth is the value of depth of the target image, then this should be some of the Data Types of depth or -1, which means the same depth that the source image.

SolutionConvert to CIELAB using OpenCV.First illustrates the 2D chart, with each color channel. Then the 3D chart for each Channel.Codeimport numpy as np import cv2 from matplotlib import pyplot as plt from mpl_toolkits.mplot3d import Axes3D def mostrar_imagem_Lab(nome, img): plt.figure(nome) plt.subplot(2, 2, 1) plt.imshow(img) plt.subplot(2, 2, 2) plt.imshow(img[:, :, 0], cmap='Greys') plt.subplot(2, 2, 3) plt.imshow(img[:, :, 1], cmap='PuBuGn_r') plt.subplot(2, 2, 4) plt.imshow(img[:, :, 2], cmap='YlGnBu_r') img = cv2.imread("C:\Users\usuario\Desktop\teste\4-cube_horribly_scrambled.png") lab_image = cv2.cvtColor(img, cv2.COLOR_BGR2LAB) h, w, c = img.shape y = range(h) x = range(w) X, Y = np.meshgrid(x, y) mostrar_imagem_Lab('Gráfico Lab', lab_image) plt.figure('Canal L') ax = plt.axes(projection='3d') ax.plot_surface(X, Y, lab_image[:, :, 0], cmap='Greys') plt.figure('Canal a') ax = plt.axes(projection='3d') ax.plot_surface(X, Y, lab_image[:, :, 1], cmap='PuBuGn_r') plt.figure('Canal b') ax = plt.axes(projection='3d') ax.plot_surface(X, Y, lab_image[:, :, 2], cmap='YlGnBu_r') plt.show() ResultsWith the following test image: The following 2D result was obtained: 3D result for channel L: 3D result for channel a: 3D result for channel b: ObservationIf the colormap is different (RGB, BGR, HSV, etc), check the following links: https://matplotlib.org/examples/color/colormaps_reference.html https://matplotlib.org/users/colormaps.html http://mpastell.com/2013/05/02/matplotlib_colormaps/

SolutionMask creation with: morphologyEx with cv2.MORPH_CLOSEcv2.blur to blur the imageBinarization with the flag cv2.THRESH_BINARY_INV+cv2.THRESH_OTSUFloodfill to eliminate the corners of the maskCut from the original image found by the mask, with logic ANDCanny Edges to find the hair and then dilationRetreats the image found by Canny Edges, with OR logicUse the Inpaint interpolation of Alexandru Telea to fill the empty spaces, predicting what should be in that empty place.Code of Exampleimport numpy as np import cv2 import urllib.request Abrir a imagem do link ou img = cv2.imread(diretorio_da_imagem//nome_do_arquivo) resp = urllib.request.urlopen("https://i.stack.imgur.com/pgW91.png") img = np.asarray(bytearray(resp.read()), dtype="uint8") img = cv2.imdecode(img, cv2.IMREAD_COLOR) kernel = np.ones((3,3),np.uint8) Utilização do morphologyEx e blur closing = cv2.morphologyEx(img,cv2.MORPH_CLOSE,kernel, iterations = 2) blur = cv2.blur(closing,(15,15)) Binarização gray = cv2.cvtColor(blur,cv2.COLOR_BGR2GRAY) _, mask = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU) cv2.imshow('Binarização',mask) cv2.waitKey(0) #Preenche os quatro cantos da imagem binária w, h = mask.shape[::-1] cv2.floodFill(mask, None, (0, 0), 0) cv2.floodFill(mask, None, (w-1, 0), 0) cv2.floodFill(mask, None, (0, h-1), 0) cv2.floodFill(mask, None, (w-1, h-1), 0) cv2.imshow('mask',mask) cv2.waitKey(0) #Lógica AND para obter da imagem original a encontrada pela criação do mask img = cv2.bitwise_and(img, img, mask=mask ) cv2.imshow('AND',img) cv2.waitKey(0) #Canny Edges edges = cv2.Canny(img, 100,200) dilate = cv2.dilate(edges,kernel,iterations=1) dilate = cv2.bitwise_not(dilate) cv2.imshow('Canny',dilate) cv2.waitKey(0) #Lógica OR para retirar da imagem original os pêlos encontrados img = cv2.bitwise_or(img, img, mask=dilate ) cv2.imshow('Edges',img) cv2.waitKey(0) #Interpolação da imagem para preencher os vazios dilate = cv2.bitwise_not(dilate) inpaint = cv2.inpaint(img, dilate, 3,cv2.INPAINT_TELEA) cv2.imshow('InPaint', inpaint) cv2.waitKey(0) cv2.destroyAllWindows() ResultsBinarization Floodfill Logic AND Canny Edges OR logic Interpolation Inpaint

To extract you can use https://docs.opencv.org/3.4.1/de/dd0/grabcut_8cpp-example.html OpenCVOne https://docs.opencv.org/3.1.0/d8/d83/tutorial_py_grabcut.html CodeUsing the example code:import numpy as np import cv2 from matplotlib import pyplot as plt img = cv2.imread('C:\Users\Desktop\teste\FHB9o.jpg') mask = np.zeros(img.shape[:2],np.uint8) bgdModel = np.zeros((1,65),np.float64) fgdModel = np.zeros((1,65),np.float64) rect = (10,10,45,45) cv2.grabCut(img,mask,rect,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT) mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8') img = img*mask2[:,:,np.newaxis] cv2.imshow('Imagem', img) cv2.waitKey(0) cv2.imwrite('C:\Users\Desktop\teste\resultado.jpg', img) plt.imshow(img),plt.colorbar(),plt.show() Results ObservationIn this case the ROI (Region of Interest) rectangular is fixed. If the images vary in the location of the object that needs to be extracted, a dynamic ROI needs to be created, where the contours will be the points that will determine the coordinates of the dynamic ROI.

First of all, you're just taking the thumb from the image, which I think in your case would not be the best case.In order to save the actual image of the camera, it is necessary to create a file and send the address to it.(Method to create timer file)String mCurrentPhotoPath; private File createImageFile() throws IOException { // Create an image file name String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()); String imageFileName = "JPEG_" + timeStamp + "_"; File storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES); File image = File.createTempFile( imageFileName, /* prefix / ".jpg", / suffix / storageDir / directory */ ); // Guarda o endereço da imagem (para utilizar no imageview, por exemplo) mCurrentPhotoPath = image.getAbsolutePath(); return image; } Method to call the cameraprivate void dispatchTakePictureIntent() { Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE); // Verifica se existe uma camera para abrir if (takePictureIntent.resolveActivity(getPackageManager()) != null) { // Cria o arquivo para salvar a imagem File photoFile = null; try { photoFile = createImageFile(); } catch (IOException ex) { // Erro criando o arquivo } // Caso o arquivo seja criado, é chamada a camera if (photoFile != null) { Uri photoURI = FileProvider.getUriForFile(this, "com.example.android.fileprovider", photoFile); takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI); startActivityForResult(takePictureIntent, REQUEST_TAKE_PHOTO); } } } With this, we can take the File returned in the createImageFile() and copy it to the desired path, and with the desired name (after saving) using the methodFileUtils.copyFile(File origem, File dest);

I searched the SO in English and saw that my slice in the array was wrong, I do the following:array[inicio:fim][incio:fim]But the right will be like this:array[inicio:fim, inicio:fim]The idea of crop in the image is correct but my application was flawed.

Similar means how similar images are, this is image processing + pattern recognition, you are looking for features that are similar between two or more images. I suggest searching for such terms on google, you can use a SIFT + KNN, for example, to compare them. In this question, he does this with SIFT, this vc algorithm finds in Python: https://stackoverflow.com/questions/1500498/how-to-use-sift-algorithm-to-compute-how-similar-two-images-are

It is a new field that has been gaining space called https://pt.wikipedia.org/wiki/Realidade_aumentada :Azuma defines augmented reality as a system that:combines virtual elements with the real environment; is interactive and has real-time processing;is conceived in three dimensions.With the great processing and memory power growing exponentially on mobile devices iterations between real and virtual environment per camera/audio is a reality, vide Pokemon Go, of course it is a game using the processing power of your smart phone to build real-time combinations of real elements (images from your camera) with virtual elements ("kicks" that seem to be in front of you when you look at the images generated by the camera).Augmented Reality is a concept, the language to do this can be any, of course in the case of Pokemon Go, and apps for Android mobiles, most of it is written in java combining codes C/C++ with JNI (Java Native Interface).The Example you gave about the APP that manages to translate words and phrases in real time pointing the mobile has a few steps, it seems magical, but it is not, if you dedicate yourself you can build a prototype of this type of algorithm using your smart phone, write down the recipe:You need to learn about image processingLinear algebra (basic calculation on x,y,z dimensions)Learn language C to write codes that identify OCR(Optical Character Recognition), simmmm of course you will need target each word/phrase/letter, you will only achieve this developing an OCR that will have the function of extracting letters from an image/camera and returning in text mode, this is a complex part of the code, usually is written in C to gain performance, you can use a library Call OpenCV, it has many functions ready to work with image processing, want to know in detail how to build a OCR the steps are in this mine https://pt.stackoverflow.com/questions/109436/o-que-%C3%A9-necess%C3%A1rio-para-ocr-android/118799#118799 or https://pt.stackoverflow.com/a/29835/7503 , if you need anything more practical I wrote a code with some concept on how to separate each letter using python https://ederwander.wordpress.com/2010/02/08/principios-para-identificacao-de-caracteres-em-python/ Learn Java(android) languageLearn how to integrate codes C with Java using JNITrain a large database using the entire alphabet with different font types (do you want your algorithm to be robust? wants it to read and identify the most sources Yeah? Arial/italic/times new roman/etc, etc.Dictionary to translate each word converted into text (i.e. you will basically need a translator of words/phrases)After you have captured the text and translated, you will now need Replace the original text with the new text, you know which ones are coordinates on the plane that your camera is capturing, certainly you must have kept the positions x,y,z at the time you segmented the word/phrase using OCR now vc only has to overlap the sentence original by the translated phrase... Ready lolOf course it is complex rsrs, but the steps are there...

Try to do it like that inside the two for:Vec3b pixel = img.at<Vec3b>(i,j); Vec3b result = logPoint(pixel); dest.at<Vec3b>(i,j)[0] = result[0]; dest.at<Vec3b>(i,j)[1] = result[1]; dest.at<Vec3b>(i,j)[2] = result[2];

Example using Pillow:#!/usr/bin/env python3 # -*- coding: utf-8 -*- """Desenhar linha em uma imagem. Utilizando o Pillow: .. code-block: pip install pillow Os valores que devem ser passados para Line(): valor inicial de x. valor inicial de y. valor final de x. valor final de y. fill é responsável por determinar a cor da linha: fill=(R, G, B, Opacidade) width determina a espessura da linha que será desenhada. Após abrir a imagem: .. code-block:: img = Image.open('NomeDaImagem.jpg') A variável img passa a ter algumas informações da imagem que foi aberta. """ from PIL import Image, ImageDraw Abrindo a imagem. img = Image.open('imagem.jpg') Colocando a imagem na área de 'desenho' draw = ImageDraw.Draw(img) Desenhando a linha: Localizando o centro da imagem. centro_x = img.size[0] / 2 centro_y = img.size[1] / 2 Tamanho da imagem. x = img.size[0] y = img.size[1] Criando a linha. draw.line((centro_x, 0, centro_x, y), fill=(255, 0, 0, 100), width=2) Descartando a área de desenho. del draw Salvando a imagem com as modificações. img.save('imagem_com_linha.jpg', 'JPEG') img.save('imagem_com_linha.png', 'PNG') Result: It is worth noting that the center of the line is using as the basis of Size Size of the image.The size of the line is going from zero up to the image size too, just adjust these values according to your needs.

Just use for each image the functions for each format:For PNG http://php.net/manual/en/function.imagecreatefrompng.php http://php.net/manual/en/function.imagepng.php To JPEG http://php.net/manual/en/function.imagecreatefromjpeg.php http://php.net/manual/en/function.imagejpeg.php For GIF http://php.net/manual/en/function.imagecreatefromgif.php http://php.net/manual/en/function.imagegif.php For WEBP (requires PHP 5.4+) http://php.net/manual/en/function.imagecreatefromwebp.php http://php.net/manual/en/function.imagewebp.php There are other clear formats, such as BMP and WBMP, but are not good formats to work with WEB, since it usually has no compression which makes a simple image quite heavy.Working without losing transparencyUse imagecreatefrompng can cause loss of transparency, so to avoid loss use:imagealphablending (resource $image , true); imagesavealpha (resource $image , true); An example of code to reduce images with PHP in different formatsFollowing the example of calculation of the response https://pt.stackoverflow.com/a/9757/3635 :<?php function image_resize($path, $width = 200, $height = 200, $save = null, $quality = 100) { $details = getimagesize($path); if (!$details) { trigger_error('Imagem inválida'); return false; } $width_orig = $details[0]; $height_orig = $details[1]; // Calculando a proporção $ratio_orig = $width_orig / $height_orig; if ($width / $height &gt; $ratio_orig) { $width = $height * $ratio_orig; } else { $height = $width / $ratio_orig; } if (is_string($save) === false) { $save = null; header('Content-Type: ' . $details['mime']); } $image_p = imagecreatetruecolor($width, $height); switch ($details['mime']) { case 'image/jpeg': $image = imagecreatefromjpeg($path); break; case 'image/gif': $image = imagecreatefromgif($path); break; case 'image/png': $image = imagecreatefrompng($path); break; case 'image/webp': $image = imagecreatefromwebp($path); break; default: trigger_error('Formato não suportado'); $image_p = null; return false; } imagecopyresampled($image_p, $image, 0, 0, 0, 0, $width, $height, $width_orig, $height_orig); if ( in_array($details['mime'], array('image/png', 'image/webp')) ) { imagealphablending($image_p, true); imagesavealpha($image_p, true); } switch ($details['mime']) { case 'image/jpeg': imagejpeg($image_p, $save, $quality); break; case 'image/gif': imagegif($image_p, $save); break; case 'image/png': imagepng($image_p, $save, $quality); break; case 'image/webp': imagewebp($image_p, $save, $quality); break; } } Example of use to copy a JPEG image to a new minor:image_resize('bar.jpg', 200, 200, 'bar_1.jpg'); To overwrite an image just use the same name:image_resize('bar.jpg', 200, 200, 'bar.jpg'); The first 200 would be the maximum width, and the second is the maximum height.

The problem is that, second https://stackoverflow.com/a/41351474/4319922 post, the folder static is only loaded at application startup by Spring Boot, any change in the content of this folder will only be reflected on the next server startup.This put, possible solutions:1) Put your images in another folder that enables Tomcat to restart automatically and, via Maven, copy them to the folder static original. This solution is https://stackoverflow.com/a/24764196/4319922 .2) Use https://paulcwarren.github.io/spring-content/ , which automates this process of guarding and recovery of static resources in the Spring environment. Give a read https://stackoverflow.com/a/50663879/4319922 post.