Existem muitos componentes ASP na Internet que geram miniaturas. Se o seu espaço virtual não suporta o registro de novos componentes, você pode sentir que seu site perdeu o brilho. Não sou muito talentoso, então combinei recursos online para escrever um programa de geração de miniaturas sem componentes apenas para referência.
Vamos dar uma olhada no básico primeiro. Primeiramente, sabemos que o código para exibir imagens na página é o seguinte:
<img src=pic.gif borda=0 largura=300 altura=260>
src é o caminho da imagem, border controla a largura da borda da imagem, width é o comprimento da imagem e height é a altura da imagem. A geração de miniaturas é, na verdade, dimensionada no tamanho original. Mas geralmente, para minimizar a distorção, escalaremos proporcionalmente. Portanto, a obtenção das dimensões de comprimento e largura da imagem passou a ser o foco da geração de miniaturas.
Aqui estão as etapas para escrever a geração de miniaturas sem componentes:
1. Obtenha o tamanho da imagem sem componentes
Não muito tempo atrás, quando aprendi ASP, vi um artigo que usava código ASCII para obter o tamanho da imagem sem componentes. Mais tarde, tentei e descobri que o tamanho das imagens jpg não podia ser exibido corretamente. Verifiquei online e descobri que muitos sites reimprimiram este programa, mas ninguém apontou as falhas deste programa, muito menos as resolveu. resolvido. Mais tarde, pesquisei novamente e finalmente encontrei um artigo que introduzia o uso de ADODB.stream para obter o tamanho da imagem. De acordo com o método introduzido, modifiquei o código interno e experimentei. com você. :
Use ADODB.stream para obter a classe geral de tamanho da imagem
<%
'///////////// GPS: Obter tamanho da imagem ///////////////
'/////////////Use ADODB.stream para obter o tamanho da imagem///////////////
'/////////Citado por Leon (心清) 11 de agosto de 2005//////////
Classe GPS
Dim também
Subclasse Privada_Initialize
Definir aso=CreateObject(Adodb.Stream)
aso.Mode=3
aso.Type=1
aso.Abrir
Finalizar sub
Subclasse Privada_Terminate
definir aso = nada
Finalizar sub
Função privada Bin2Str(Bin)
Dim I, Str
Para I=1 para LenB(Bin)
clow=MidB(Bin,I,1)
se AscB(clow)<128 então
Str = Str & Chr(ASCB(clow))
Outro
Eu=eu+1
se eu <= LenB(Bin) então Str = Str & Chr(ASCW(MidB(Bin,I,1)&clow))
fimSe
Próximo
Bin2Str = Str
Função final
Função privada Num2Str(num,base,lente)
'GPS (11/08/2005)
escuro
ret =
enquanto(num>=base)
ret = (num mod base) & ret
num = (num - num mod base)/base
vamos
Num2Str = direita(string(lente,0) & num & ret,lente)
Função final
Função privada Str2Num(str,base)
'GPS (11/08/2005)
escuro
ret = 0
para i=1 para len(str)
ret = ret *base + cint(mid(str,i,1))
próximo
Str2Num=ret
Função final
Função privada BinVal(bin)
'GPS (11/08/2002)
escuro
ret = 0
para i = lenb(bin) para 1 passo -1
ret = ret *256 + ascb(midb(bin,i,1))
próximo
BinVal=ret
Função final
Função privada BinVal2(bin)
'GPS (11/08/2002)
escuro
ret = 0
para i = 1 para lenb(bin)
ret = ret *256 + ascb(midb(bin,i,1))
próximo
BinVal2=ret
Função final
'///A seguir está o código de chamada ///
Função getImageSize(filespec)
'GPS (11/08/2002)
escurecer ret(3)
aso.LoadFromFile(filespec)
bFlag=aso.read(3)
selecione caso hexadecimal (binVal (bFlag))
caso 4E5089:
aso.ler(15)
ret(0)=PNG
ret(1)=BinVal2(aso.read(2))
aso.ler(2)
ret(2)=BinVal2(aso.read(2))
caso 464947:
aso.ler(3)
ret(0)=GIF
ret(1)=BinVal(aso.read(2))
ret(2)=BinVal(aso.read(2))
caso 535746:
aso.ler(5)
binData=aso.Read(1)
sConv=Num2Str(ascb(binData),2,8)
nBits=Str2Num(esquerda(sConv,5),2)
sConv=meio(sConv,6)
while(len(sConv)<nBits*4)
binData=aso.Read(1)
sConv=sConv&Num2Str(ascb(binData),2,8)
vamos
ret(0)=SWF
ret(1)=int(abs(Str2Num(mid(sConv,1*nBits+1,nBits),2)-Str2Num(mid(sConv,0*nBits+1,nBits),2))/20)
ret(2)=int(abs(Str2Num(mid(sConv,3*nBits+1,nBits),2)-Str2Num(mid(sConv,2*nBits+1,nBits),2))/20)
caso FFD8FF:
fazer
faça: p1=binVal(aso.Read(1)): loop while p1=255 e não aso.EOS
se p1>191 e p1<196 então saia faça else aso.read(binval2(aso.Read(2))-2)
do:p1=binVal(aso.Read(1)):loop while p1<255 e não aso.EOS
loop enquanto verdadeiro
também.Leia(3)
ret(0)=JPG
ret(2)=binval2(aso.Read(2))
ret(1)=binval2(aso.Leitura(2))
caso contrário:
se esquerda(Bin2Str(bFlag),2)=BM então
também.Leia(15)
ret(0)=BMP
ret(1)=binval(aso.Read(4))
ret(2)=binval(aso.Read(4))
outro
ret(0)=
terminar se
final selecionar
ret(3)=largura= & ret(1) & altura=
&ret(2)&
getimagesize=ret
Função final
Fim da aula
%>
Copie o código acima para gerar o arquivo GPS.asp, para que a classe geral para obtenção do tamanho da imagem sem componentes esteja correta.
2. Obtenha o caminho da imagem
Como existe mais de uma imagem e as imagens precisam ser armazenadas em categorias, criamos um campo ImgURL no banco de dados para armazenar o caminho relativo da imagem. Colocamos todas as fotos enviadas em uma pasta chamada imagens (não entrarei em detalhes sobre como fazer upload de fotos sem componentes). Agora, primeiro criamos uma página ShowImg.asp para exibir miniaturas e informações relacionadas. O design específico é o seguinte:
foto:
Formato da imagem:
Tamanho da imagem:
Tamanho da imagem:
Número de cliques:
A seguir, obtemos o caminho absoluto da imagem. O código é o seguinte:
<%
'/////Obtém o caminho absoluto de ShowImg.asp/////
Dim curFile
curFile=Server.mappath(Request.servervariables(PATH_INFO))
Dim curfilename,nome do arquivo
'/////Caminho relativo para a imagem (armazenado no banco de dados)
cufilename=rs(ImgURL)
'/////Como ShowImg.asp está no mesmo diretório das imagens, usamos instrrev para obter o caminho das imagens/////
nome do arquivo=left(curFile,instrrev(curFile,/))&cufilename
'/////Criar entidade de classe GPS /////
Dim GetPicSize
Definir GetPicSize = novo GPS
Definir fs=Server.CreateObject(Scripting.FileSystemObject)
'/////Obter o tipo de imagem /////
Dim PicSuffixName
PicSuffixName=fs.GetExtensionName(nome do arquivo)
Dim PD '//Dimensão da imagem
Dim PWidth, PHeight
Selecione o caso PicSuffixName
Caso gif,bmp,jpg,png:
'/////Chame a função GetImageSize na classe geral do GPS para obter o tamanho da imagem/////
PD=GetPicSize.GetImageSize(nome do arquivo)
PWidth=PD(1) '//Obtém a largura da imagem
PHeight=PD(2) '//Obtém a altura da imagem
Caso swf
PD=GetPicSize.GetImageSize(nome do arquivo)
PWidth=PD(1) '//Obter largura do Flash
PHeight=PD(2) '//Obtém a altura do Flash
Outro caso
Finalizar seleção
Definir fs=Nada
Definir GetPicSize=Nada
%>
Copie o código acima para o topo de <body> e está tudo bem!
Claro, algumas pessoas dirão que você não precisa usar PATH_INFO para obter o caminho. Você pode apenas usar server.mappath() diretamente. Cada um tem suas próprias preferências. percebi que algumas funções do FSO e use server .mappath() não funcionaram, então continuei usando isso.
3. Defina o tamanho da miniatura
Esta parte do código está nos olhos de quem vê, e os sábios veem a sabedoria. Primeiro, precisamos especificar o intervalo de tamanho de exibição da miniatura, por exemplo: 300X260. O código pode ser escrito assim:
<%
Dim PXWidth,PXHeight
Dim Pp '//Proporção
Se PWidth=0 ou PWidth= Então
Largura PX=0
Altura PX = 0
Outro
Pp=FormatNumber(PWidth/PHeight,2) '//Proporção
Terminar se
Se PWidth>=PHeight Então
Se PWidth>=300 Então
Largura PX=300
PXHeight=FormatoNúmero(300/Pp,0)
Outro
PXLargura=PLargura
PXAltura=PAltura
Terminar se
Outro
Se PHeight>=260 Então
Altura PX=260
PXWidth=FormatoNúmero(260*Pp,0)
Outro
PXLargura=PLargura
PXAltura=PAltura
Terminar se
Terminar se
%>
Basta escrever o código acima imediatamente após a segunda etapa. O código ao chamar é o seguinte:
<img src=<%=curfilename%> borda=0 largura=<%=PXWidth%>
altura=<%=PXAltura%>>
Quanto ao formato da imagem, você pode usar <%=PicSuffixName%> para obtê-lo, e o tamanho da imagem pode ser escrito como
<%
resposta.write PXWidth&X&PXHeight
%>
O tamanho da imagem pode ser realizado usando FSO.GetFileSize(filename), e o número de cliques pode ser simplesmente realizado usando instruções SQL. A codificação específica não será descrita novamente.
Desta forma, um programa de geração de miniaturas sem componentes foi escrito. Pode ser um pouco emprestado, mas contanto que todos possam dominar o método, acredito que será muito melhorado.