Hay muchos componentes ASP en Internet que generan miniaturas. Si su espacio virtual no admite el registro de nuevos componentes, puede sentir que su sitio web ha perdido su brillo. No tengo mucho talento, así que combiné recursos en línea para escribir un programa de generación de miniaturas sin componentes solo como referencia.
Primero echemos un vistazo a los conceptos básicos. Primero, sabemos que el código para mostrar imágenes en la página es el siguiente:
<img src=pic.gif borde=0 ancho=300 alto=260>
src es la ruta de la imagen, el borde controla el ancho del borde de la imagen, el ancho es la longitud de la imagen y la altura es la altura de la imagen. La generación de miniaturas en realidad se escala según el tamaño original. Pero, en general, para minimizar la distorsión, escalaremos proporcionalmente. Por lo tanto, obtener las dimensiones de largo y ancho de la imagen se ha convertido en el foco de la generación de miniaturas.
Estos son los pasos para escribir la generación de miniaturas sin componentes:
1. Obtener el tamaño de la imagen sin componentes
No hace mucho, cuando aprendí ASP por primera vez, vi un artículo que usaba código ASCII para obtener el tamaño de una imagen sin componentes. Más tarde, lo probé y descubrí que el tamaño de las imágenes jpg no se podía mostrar correctamente. Verifiqué en línea y descubrí que muchos sitios web reimprimieron este programa, pero nadie señaló las fallas de este programa, y mucho menos lo resolvió. resuelto. Más tarde, busqué en Google nuevamente y finalmente encontré un artículo que presentaba el uso de ADODB.stream para obtener el tamaño de la imagen. Modifiqué el código interno de acuerdo con el método y lo probé. Ahora lo compartiré. contigo. :
Utilice ADODB.stream para obtener la clase general de tamaño de imagen
<%
'///////////// GPS: Obtener tamaño de imagen ///////////////
'//////////////Utilice ADODB.stream para obtener el tamaño de la imagen///////////////
'/////////Citado por Leon (心清) 11 de agosto de 2005//////////
Clase GPS
tenue también
Subclase privada_Inicializar
Establecer como=CreateObject(Adodb.Stream)
aso.Modo=3
aso.Tipo=1
aso.Abierto
Subtítulo final
Subclase privada_Terminar
establecer como = nada
Subtítulo final
Función privada Bin2Str(Bin)
Dim I, Str
Para I=1 a LenB(Bin)
clow=MidB(Bin,I,1)
si AscB(clow)<128 entonces
Str = Str y Chr(ASCB(clow))
Demás
yo=yo+1
si I <= LenB(Bin) entonces Str = Str & Chr(ASCW(MidB(Bin,I,1)&clow))
final si
Próximo
Bin2Str = Cadena
Función final
Función privada Num2Str(num,base,lente)
'GPS (2005-8-11)
retiro oscuro
retirarse =
mientras(núm>=base)
ret = (núm base mod) & ret
núm = (núm - núm mod base)/base
encaminarse a
Num2Str = derecha(cadena(lente,0) & num & ret,lente)
Función final
Función privada Str2Num(cadena,base)
'GPS (2005-8-11)
retiro oscuro
retiro = 0
para i=1 a len(cadena)
ret = ret *base + cint(medio(cadena,i,1))
próximo
Str2Num=ret
Función final
Función privada BinVal(bin)
'GPS (2002-8-11)
retiro oscuro
retiro = 0
para i = lenb(bin) a 1 paso -1
ret = ret *256 + ascb(midb(bin,i,1))
próximo
BinVal=ret
Función final
Función privada BinVal2(bin)
'GPS (2002-8-11)
retiro oscuro
retiro = 0
para i = 1 a lenb(bin)
ret = ret *256 + ascb(midb(bin,i,1))
próximo
BinVal2=ret
Función final
'///El siguiente es el código de llamada///
Función getImageSize (especificación de archivo)
'GPS (2002-8-11)
retiro tenue(3)
aso.LoadFromFile (especificación de archivo)
bFlag=aso.read(3)
seleccione caso hexadecimal (binVal (bFlag))
caso 4E5089:
aso.leer(15)
ret(0)=PNG
ret(1)=BinVal2(aso.read(2))
aso.leer(2)
ret(2)=BinVal2(aso.read(2))
caso 464947:
aso.leer(3)
retiro(0)=GIF
ret(1)=BinVal(aso.read(2))
ret(2)=BinVal(aso.read(2))
caso 535746:
aso.leer(5)
binData=aso.Read(1)
sConv=Num2Str(ascb(binData),2,8)
nBits=Str2Num(izquierda(sConv,5),2)
sConv=media(sConv,6)
mientras(len(sConv)<nBits*4)
binData=aso.Read(1)
sConv=sConv&Num2Str(ascb(binData),2,8)
encaminarse a
retiro(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:
hacer
hacer: p1=binVal(aso.Read(1)): bucle mientras p1=255 y no aso.EOS
si p1>191 y p1<196 entonces salga, haga lo contrario aso.read(binval2(aso.Read(2))-2)
do:p1=binVal(aso.Read(1)): bucle mientras p1<255 y no aso.EOS
bucle mientras es verdadero
aso.Leer(3)
retirar(0)=JPG
ret(2)=binval2(aso.Read(2))
ret(1)=binval2(aso.Read(2))
caso más:
si izquierda (Bin2Str (bFlag), 2) = BM entonces
aso.Leer(15)
retiro(0)=BMP
ret(1)=binval(aso.Read(4))
ret(2)=binval(aso.Read(4))
demás
retirar(0)=
terminar si
finalizar seleccionar
ret(3)=ancho= & ret(1) & alto=
& retirar(2)&
getimagesize=ret
Función final
Fin de clase
%>
Copie el código anterior para generar el archivo GPS.asp, de modo que la clase general para obtener el tamaño de la imagen sin componentes esté bien.
2. Obtenga la ruta de la imagen.
Dado que hay más de una imagen y las imágenes deben almacenarse en categorías, diseñamos un campo ImgURL en la base de datos para almacenar la ruta relativa de la imagen. Colocamos todas las imágenes cargadas en una carpeta llamada imágenes (no entraré en detalles sobre cómo cargar imágenes sin componentes). Ahora primero diseñamos una página ShowImg.asp para mostrar miniaturas e información relacionada. El diseño específico es el siguiente:
imagen:
Formato de imagen:
Tamaño de imagen:
Tamaño de imagen:
Número de clics:
A continuación, obtenemos la ruta absoluta de la imagen. El código es el siguiente:
<%
'/////Obtener la ruta absoluta de ShowImg.asp/////
Archivo curvo tenue
curFile=Servidor.mappath(Solicitud.servervariables(PATH_INFO))
Dim curfilename, nombre de archivo
'/////Ruta relativa a la imagen (almacenada en la base de datos)
cufilename=rs(ImgURL)
'/////Debido a que ShowImg.asp está en el mismo directorio que las imágenes, usamos instrrev para obtener la ruta de las imágenes/////
nombre de archivo=left(curFile,instrrev(curFile,/))&cufilename
'/////Crear entidad de clase GPS/////
Tamaño de imagen tenue
Establecer GetPicSize = nuevo GPS
Establecer fs=Server.CreateObject(Scripting.FileSystemObject)
'/////Obtener el tipo de imagen/////
Nombre de sufijo de imagen tenue
PicSuffixName=fs.GetExtensionName(nombre de archivo)
Dim PD '//Dimensión de imagen
Dim PAncho, PHalto
Seleccione Caso PicSuffixName
Caso gif,bmp,jpg,png:
'///// Llame a la función GetImageSize en la clase general de GPS para obtener el tamaño de la imagen /////
PD=GetPicSize.GetImageSize(nombre de archivo)
PWidth=PD(1) '//Obtener el ancho de la imagen
PHeight=PD(2) '//Obtener la altura de la imagen
caso swf
PD=GetPicSize.GetImageSize(nombre de archivo)
PWidth=PD(1) '//Obtener ancho de Flash
PHeight=PD(2) '//Obtener la altura del Flash
Caso más
Seleccionar fin
Establecer fs=Nada
Establecer GetPicSize=Nada
%>
Copie el código anterior en la parte superior de <body> y ¡listo!
Por supuesto, algunas personas dirán que no es necesario usar PATH_INFO para obtener la ruta. Puedes usar server.mappath() directamente. Jaja, cada uno tiene sus propias preferencias. La razón principal es que puedo usar PATH_INFO para hacerlo. Realizar algunas funciones de FSO y usar el servidor .mappath() no funcionó, así que seguí usando esto.
3. Definir el tamaño de la miniatura
Esta parte del código está en el ojo del que mira, y los sabios ven la sabiduría. Primero, debemos especificar el rango de tamaño de visualización de las miniaturas, por ejemplo: 300X260. El código se puede escribir así:
<%
Dim PXWidth, PXHeight
Dim Pp '//Proporción
Si PWidth=0 o PWidth= Entonces
Ancho PX=0
Altura PX=0
Demás
Pp=NúmeroFormato(PAncho/PAltura,2) '//Relación de aspecto
Terminar si
Si PAncho>=PAltura Entonces
Si PWidth>=300 Entonces
Ancho PX=300
Altura PX=Número de formato(300/Pp,0)
Demás
PXAncho=PAncho
Altura PX = Altura PX
Terminar si
Demás
Si PHeight>=260 Entonces
Altura PX=260
Ancho PX = Número de formato (260 * Pp, 0)
Demás
PXAncho=PAncho
Altura PX = Altura PX
Terminar si
Terminar si
%>
Simplemente escriba el código anterior inmediatamente después del segundo paso. El código al llamar es el siguiente:
<img src=<%=curfilename%> border=0 ancho=<%=PXWidth%>
altura=<%=PXAltura%>>
En cuanto al formato de la imagen, puede usar <%=PicSuffixName%> para obtenerlo y el tamaño de la imagen se puede escribir como
<%
respuesta.escribir PXWidth&X&PXHeight
%>
El tamaño de la imagen se puede lograr usando FSO.GetFileSize (nombre de archivo), y el número de clics se puede lograr simplemente usando declaraciones SQL. La codificación específica no se describirá nuevamente.
De esta manera, se ha escrito un programa de generación de miniaturas sin componentes. Puede que sea un poco prestado, pero siempre que todos puedan dominar el método, creo que mejorará enormemente.