Olá pessoal, Estou com muito dificuldade de finalizar essas questões, o foda de tudo que seria em grupo e eu por não conhecer ninguém estou batendo cabeça sozinho e to errando bastante para finalizar as ultimas questões, quem puder eu agradeço de coração!
Alguns algoritmos para reconhecimento ótico de caracteres compara a imagem “scanneada” com modelos
de caracteres perfeitos. Parte da dificuldade com tais comparações é decidir onde começar a comparação.
Isto se deve ao fato de que as imagens “scanneadas” estão sujeitas a distorções, resultando em mudanças
no tamanho, posição e orientação. Um procedimento que algumas vezes é utilizada para lidar com essas
mudanças na posição é “casar” o centro de gravidade do caractere “scanneado” com centro de gravidade
do modelo com o qual ele é comparado. Neste problema você determinará os centros de gravidades das
imagens dos caracteres “scanneados”.
Para os nossos propósitos, um caractere “scanneada” será uma matriz retangular de números reais com
valores em uma escala de cinza. A escala de cinza tem valores entre 0 (representando uma região
totalmente branca) e 1 (representando uma região totalmente preta).
O centro de gravidade é um elemento particular de uma matriz. Suponha um centro de gravidade na iésima linha e j-ésima coluna. Então a diferença entre a soma dos elementos das duas porções da matriz
acima e abaixo da i-ésima linha é mínima. Do mesmo modo, a diferença entre a soma dos elementos das
duas porções a esquerda e direita da j-ésima coluna é mínima.
Como exemplo, considere que a matriz abaixo representa o caractere “o” “scanneado”. O centro de
gravidade desta matriz está singularmente na 3º linha, e 3º coluna, pois a diferença entre a soma dos
elementos em cada porção da matriz informada, ignorando a terceira linha é 0,1 (as somas das porções
abaixo e acima são 5,55 e 5,65, respectivamente). A diferença entre a soma de cada porção da matriz
formada ignorando a terceira coluna é 0,0 (a soma de ambas porções é 5,60).
0.7 0.75 0.7 0.75 0.8
0.55 0.3 0.2 0.1 0.7
0.8 0.1 0.0 0.0 0.8
0.7 0.0 0.0 0.0 0.8
0.8 0.9 0.8 0.75 0.9
Entrada
A entrada do seu programa deve ser realizada a partir de um arquivo texto com seguinte formato: No início
do arquivo teremos dois inteiros especificando a quantidade de linhas e colunas de uma matriz retangular,
em seguida os valores em ponto flutuante (de 0 até 1 com precisão de uma casa decimal) representando a
escala de cinza do caractere “scanneado”. Além disso, considere que a matriz sempre terá no mínimo 3
linhas e 3 colunas.
Exemplos de entrada
5 5
0.1 0.2 0.1 0.2 0.1
0.1 0.2 0.3 0.1 0.1
0.2 0.3 0.1 0.1 0.3
0.4 0.1 0.1 0.1 0.2
0.2 0.2 0.3 0.3 0.1
5 10
0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1
0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2 0.2
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4 0.4
0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5
Saída
Para cada caractere deverá mostrar na tela a linha e a coluna correspondente ao centro de gravidade. Se
houver mais de um centro de gravidade, apresente somente o primeiro encontrado.
Exemplo de saída
caso 1: Centro ( 3, 3 )
caso 2: Centro ( 4, 5 )
Bom, eu fiz algo para tu se basear. Logo, é passível de erros:
import java.util.Scanner;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.FileNotFoundException;
public class CentroGravidade {
public static void main(String[] args){
int linha; //Armazenha a linha informada no txt
int coluna; //Armazenha a coluna informada no txt
int linhaMarcada = 0; //Armazena a linha que compõe o centro de gravidade
int colunaMarcada = 0; //Armazena a coluna que compõe o centro de gravidade
int indice = 2; //Indice do vetor de doubles, descontados os valores informados para a linha e a coluna
double[] valoresDouble; //Armazena os valores convertidos de String para double
double[] somatorioLinha; //Armazena as somas de cada linha
double[] somatorioColuna; //Armazena as somas de cada coluna
double linhaMaior; //Valor arbitrário para a linha que compõe o centro de gravidade
double colunaMaior; //Valor arbitrário para a coluna que compõe o centro de gravidade
double[][] dadosTabulados; //Armazena os valores em formato matricial
String enderecoArquivo = "C:/Users/JFSJUNIOR/Desktop/baseDados.txt";
String dados = null; //Armazena os valores de todas as linhas lidas
String linhaLida; //Armazena cada linha lida
String[] valoresString; //Armazena os valores da String dados
Scanner leitor = new Scanner(System.in); //Caso queira informar o caminho do arquivo pelo console
//Tratamento de exceções
try{
FileReader leitorArquivo = new FileReader(enderecoArquivo); //Lê um arquivo de texto
BufferedReader buffer = new BufferedReader(leitorArquivo); //Lê um fluxo de caracteres armazenando-os em um buffer
linhaLida = buffer.readLine(); //Lê uma linha
dados = linhaLida; //Coloca a linha lida na String dados
while(linhaLida != null){
linhaLida = buffer.readLine(); //Lê uma linha
dados += linhaLida; //Contaena a primeira linha lida com as demais
}
leitorArquivo.close(); //Fecha o FileReader
}catch(IOException ioex){
System.out.println("ERRO: " + ioex.getMessage());
}
//Mostra o tamanho dos dados se houver
if(dados != null)
System.out.print("\tTamanho da linha: " + dados.length() + "\n");
else
System.out.println("\tTamanho da linha: " + 0 + "\n");
//Separa os valores da String dados com base em espaços
valoresString = dados.split(" ");
valoresDouble = new double[valoresString.length - 1]; //Determina o tamanho do vetor valoresDouble
//Converte double e adiciona cada valor de do vetor de Strings valoresString em valoresDouble
for(int i = 0; i < (valoresDouble.length); i++){
valoresDouble[i] = Double.valueOf(valoresString[i]).doubleValue();
}
linha = (int) valoresDouble[0]; //Obtém o valor da linha informada no txt
coluna = (int) valoresDouble[1]; //Obtém o valor da coluna informada no txt
dadosTabulados = new double[linha][coluna]; //Define o tamanho da matriz dadosTabulados
somatorioLinha = new double[linha]; //Define o tamanho da matriz somatorioLinha
somatorioColuna = new double[coluna]; //Define o tamanho da matriz somatorioColuna
System.out.println("\nDados lidos e convertidos para double");
for(int i = 0; i < valoresDouble.length; i++){
System.out.print(valoresDouble[i] + "\n");
}
//Passando os dados do vetor valoresDouble para a matriz dadosTabulados
for(int i = 0; i < linha; i++){
for(int j = 0; j < coluna; j++){
dadosTabulados[i][j] = valoresDouble[indice++];
}
}
System.out.println("\nDados em formato matricial");
for(int i = 0; i < linha; i++){
for(int j = 0; j < coluna; j++){
System.out.print(dadosTabulados[i][j] + " ");
}
System.out.println("");
}
System.out.println("\nObtendo os somatórios...");
for(int i = 0; i < linha; i++){
for(int j = 0; j < coluna; j++){
somatorioLinha[i] += dadosTabulados[i][j];
somatorioColuna[i] += dadosTabulados[j][i];
}
System.out.println("Linha["+ i +"]-> " + somatorioLinha[i]);
System.out.println("Coluna["+ i +"]-> " + somatorioColuna[i]);
}
linhaMaior = dadosTabulados[0][0];
colunaMaior = dadosTabulados[0][0];
//Obtém a linha e a coluna de maior peso, bem como o índice da linha e da coluna
for(int i = 0; i < somatorioLinha.length; i++){
if(linhaMaior < somatorioLinha[i]){
linhaMaior = somatorioLinha[i];
linhaMarcada = i;
}
if(colunaMaior < somatorioColuna[i]){
colunaMaior = somatorioColuna[i];
colunaMarcada = i;
}
}
System.out.println("\nLinha de maior peso: " + linhaMaior + " - Coluna de maior peso: " + colunaMaior);
System.out.println("\nCentro de gravidade = [" + linhaMarcada + "," + colunaMarcada + "]");
}
}
Rodando…
Observações:
1 - Para funcionar o contente, separa os valores no txt por espaços, como pede o execício;
2 - Depois de informa a coluna mo txt (primeira linha), dê um espaço, para só então dar quebra de linha (enter);
3 - Dê um espaço depois de informar o último valor na segunda linha do txt.
O txt:
