Recentemente, os códigos de verificação deslizantes se tornaram gradualmente populares em muitos sites. Por um lado, é relativamente novo para a experiência do usuário e simples de operar. Por outro lado, a segurança não foi bastante reduzida em comparação com os códigos de verificação gráfica. Obviamente, até agora, não há verificação absoluta de segurança, mas está apenas aumentando o custo do desvio para os atacantes.
Em seguida, analise o processo principal do código de verificação deslizante:
Gera aleatoriamente recortes e imagens de fundo com sombras de corte no back -end e salva coordenadas de posição de corte aleatório em segundo plano.
O front-end realiza interação deslizante, coloca o recorte na sombra do recorte e obtém o valor da distância deslizante do usuário, como o exemplo a seguir
O front-end passa o valor da distância deslizante do usuário para o back-end e o back-end verifica se o erro está dentro do intervalo permitido.
Aqui, simplesmente verificar a distância deslizante do usuário é a verificação mais básica. Por razões de segurança mais altas, toda a trajetória do deslizamento do usuário, o comportamento de acesso do usuário na página atual etc. também pode ser considerado. Isso pode ser complexo e, mesmo com a ajuda dos modelos de análise de dados de comportamento do usuário, o objetivo final é aumentar a dificuldade de simulação ilegal e ignorar. Essas são as oportunidades que podem ser resumidas e resumidas, métodos comumente usados. Este artigo se concentra em como gerar códigos de verificação deslizante passo a passo com base no Java.
Pode -se observar que o código de verificação gráfica deslizante consiste em duas imagens importantes, o corte de blocos e a imagem original com a sombra de corte de blocos. Existem duas características importantes aqui para garantir a dificuldade de ser forçado a ser forçado: a forma do corte do bloco e a posição da imagem original em que o bloco está localizado é aleatório. Isso permite que pares aleatórios e irregularmente encontrados de recortes e imagens originais sejam criados em um conjunto limitado de imagens.
Como usar o código para extrair uma imagem pequena com uma forma aleatória específica de uma imagem grande?
A primeira etapa é determinar o esboço da imagem de corte para facilitar a execução real da operação de processamento de imagem no futuro.
A imagem é composta de pixels e cada ponto de pixel corresponde a uma cor. A cor pode ser representada na forma RGB, além de uma transparência, e entender uma imagem como uma figura plana, com o canto superior esquerdo como origem, para o eixo x direito e para o eixo y para baixo, uma valor de coordenada corresponde à cor do ponto de pixel na posição correspondente, de modo que uma imagem pode ser convertida em uma prisão bidimensional. Com base nessa consideração, o esboço também é representado por uma matriz bidimensional, com o valor do elemento dentro do contorno 1 e o valor do elemento fora do contorno sendo 0.
Neste momento, você deve pensar em como gerar essa forma de esboço. Existem sistemas de coordenadas, retângulos e círculos. Sim, são usadas funções gráficas matemáticas. Normalmente, as funções usando a equação da função de um círculo e a função da linha lateral de um retângulo, semelhante a:
Em (Xa) ²+(yb) ² = r², existem três parâmetros A, B e R, ou seja, a coordenada central é (a, b) e o raio r. Esses recortes são colocados no sistema de coordenadas descritos acima e é fácil calcular os valores específicos do gráfico.
O código de amostra é o seguinte:
private int [] [] getBlockData () {int [] [] data = new int [TargetLength] [TargetWidth]; duplo x2 = alvoLength-Circler-2; // a posição do círculo gerado aleatoriamente duplo h1 = circler + math.random () * (TargetWidth-3 * Circler-r1); Double PO = Circler*Circler; duplo xbegin = TargetLength-Circler-R1; duplo ybegin = TargetWidth-Circler-R1; para (int i = 0; i <TargetLength; i ++) {for (int j = 0; j <TargetWidth; J ++) {// direita ○ Double d3 = Math.pow (i - x2,2)+Math.pow (J - H1,2); if (d1 <= po || (j> = ybegin && d2> = po) || (i> = xbegin && d3> = po)) {data [i] [j] = 0; } else {data [i] [j] = 1; }}} retornar dados; }A segunda etapa é que, após esse esboço, você pode determinar o corte com base no valor dessa matriz bidimensional e adicionar uma sombra à posição de corte na imagem original.
A operação é a seguinte:
private void cutbyTemplate (bufferImage oriimage, bufferImage TargetImage, int [] [] modelimage, int x, int y) {for (int i = 0; i <TargetLength; i ++) {para (int j = 0; j <TargetWidth; j ++) {int rgb = modelo [i] [i] [j]; // O processo de descoloração da cor na posição correspondente na imagem original int rgb_ori = oriimage.getRGB (x + i, y + j); if (rgb == 1) {// copie o valor de cor correspondente na imagem de corte TargetImage.setrgb (i, y + j, rgb_ori); int r = (0xff & rgb_ori); int g = (0xff & (rgb_ori >> 8)); int b = (0xff & (rgb_ori >> 16))); rgb_ori = r + (g << 8) + (b << 16) + (200 << 24); // a mudança de cor da posição correspondente da imagem original oriimage.setrgb (x + i, y + j, rgb_ori); }}}}Após as duas primeiras etapas, você receberá o recorte e a imagem original com sombra de corte. Para aumentar a confusão e melhorar o efeito de carregamento da rede, também é necessário um processamento adicional de imagens. Geralmente, há duas coisas para fazer. Um é embaçar a imagem e aumentar a dificuldade do reconhecimento de máquinas, e o outro é executar a compressão apropriada da mesma qualidade. O processamento difuso é fácil de pensar na difusão gaussiana, e o princípio é fácil de entender. Você pode ir ao Google para aprender sobre isso. Especificamente para a implementação do Java, existem muitas versões. Agora, não há frascos de terceiros para fornecer um exemplo:
Public Static Convolveop GetgaussianBlurFilter (Int Radius, Boolean Horizontal) {if (Radius <1) {lança nova ilegalArgumentException ("Radius deve ser> = 1"); } int size = raio * 2 + 1; float [] dados = novo float [size]; float sigma = raio / 3.0f; flutuar twosigmasquare = 2.0f * sigma * sigma; float sigmaroot = (float) math.sqrt (twosigmasquare * math.pi); Float Total = 0,0f; para (int i = -radius; i <= raio; i ++) {Distância do float = i * i; int index = i + raio; dados [index] = (float) math.exp (-distance / twosigmasquare) / sigmaroot; total += dados [índice]; } para (int i = 0; i <data.length; i ++) {data [i] /= total; } Kernel kernel = nulo; if (horizontal) {kernel = novo kernel (tamanho, 1, dados); } else {kernel = novo kernel (1, tamanho, dados); } retornar novo Convolveop (kernel, complveop.edge_no_op, null); } public static void simplesblur (bufferImage src, bufferiMage dest) {bufferImageop op = getgaussianblurfilter (2, false); op.filter (SRC, dest); }O efeito embaçado foi muito bom após o teste. Além disso, é compactação de imagem e nenhuma ferramenta de terceiros é usada para realizar compressão homogênea.
public static byte [] FromBufferImage2 (BufferImage IMG, String ImageType) lança IoException {Bos.Reset (); // Get the Writer Iterator <MageWriter> iter = imageio.getImageWritersByFormatName (ImagType); ImageWriter Writer = (ImageWriter) Iter.Next (); // Obtenha as configurações de parâmetro de saída do escritor especificado (ImageWriteParam) ImageWriteParam IWP = writer.getDefaultWriteParam (); iwp.setCompressionMode (ImageWriteParam.mode_explicit); // Defina se deve comprimir iwp.setcompressionquity (1f); // Defina parâmetros de qualidade de compressão iwp.setProgressivEmode (imageWriteParam.mode_disabled); Colormodel colormodel = colormodel.getRgbDefault (); // Especifique o modo de cor usado durante a compactação iwp.setDestinationType (new javax.imageio.imageTyPespecifier (colormodel, colormodel.createCompatiblesamplemodel (16, 16)); writer.setOutput (imageio .CreateImageOutputStream (BOS)); Iioimage iiamge = novo iioimage (img, null, null); writer.write (null, iiamge, iwp); byte [] d = bos.tobytearray (); retornar d; }Nesse ponto, o processo de processamento de código do núcleo do código de verificação deslizante foi concluído. Existem muitos detalhes que podem ser polidos e otimizados continuamente, para que a experiência deslizante possa ser melhor. Espero que possa ajudar alguns alunos que estão se preparando para construir seu próprio código de verificação deslizante.
As implementações de código acima são muito refinadas. Por um lado, para garantir o desempenho e, por outro lado, é fácil de entender. Além disso, devido a vários motivos, não é conveniente introduzir muitos detalhes. Se você tiver alguma dúvida, pode deixar uma mensagem para se comunicar. Após o teste, o tempo de resposta do processo da geração de gráficos deslizantes pode ser controlado a cerca de 20 ms. Se a resolução original da imagem estiver abaixo de 300px*150px, poderá atingir cerca de 10ms, que está dentro de um intervalo aceitável. Se houver uma maneira mais eficiente, espero me dar alguns conselhos. Eu também espero que todos apoiem mais wulin.com.