Il existe de nombreux composants ASP sur Internet qui génèrent des miniatures. Si votre espace virtuel ne prend pas en charge l’enregistrement de nouveaux composants, vous pourriez avoir l’impression que votre site Web a perdu de son éclat. Je ne suis pas très talentueux, j'ai donc combiné des ressources en ligne pour écrire un programme de génération de vignettes sans composants, à titre de référence uniquement.
Jetons d’abord un coup d’œil aux bases. Premièrement, on sait que le code pour afficher les images sur la page est le suivant :
<img src=pic.gif border=0 largeur=300 hauteur=260>
src est le chemin de l'image, border contrôle la largeur du bord de l'image, la largeur est la longueur de l'image et la hauteur est la hauteur de l'image. La génération de vignettes est en fait adaptée à la taille d'origine. Mais généralement, afin de minimiser la distorsion, nous procéderons à une échelle proportionnelle. Par conséquent, l’obtention des dimensions de longueur et de largeur de l’image est devenue l’objectif de la génération de vignettes.
Voici les étapes pour écrire une génération de vignettes sans composants :
1. Obtenez la taille de l'image sans composants
Il n'y a pas si longtemps, lorsque j'ai appris ASP pour la première fois, j'ai vu un article qui utilisait le code ASCII pour obtenir la taille d'une image sans composants. Plus tard, je l'ai essayé et j'ai découvert que la taille des images jpg ne pouvait pas être affichée correctement. J'ai vérifié en ligne et j'ai découvert que de nombreux sites Web réimprimaient ce programme, mais personne n'a signalé les défauts de ce programme, et encore moins ne l'a pas résolu. résolu. Plus tard, j'ai cherché à nouveau sur Google et j'ai finalement trouvé un article qui présentait l'utilisation de ADODB.stream pour obtenir la taille de l'image. Selon la méthode introduite, j'ai modifié le code à l'intérieur et je l'ai essayé. L'effet est vraiment bon. avec toi :
Utilisez ADODB.stream pour obtenir la classe générale de taille d'image
<%
'///////////// GPS : obtenir la taille de l'image ///////////////
'//////////////Utilisez ADODB.stream pour obtenir la taille de l'image///////////////
'/////////Cité par Léon (心清) le 11 août 2005//////////
GPS de classe
Faible aussi
Sous-classe privée_Initialize
Définir aso=CreateObject(Adodb.Stream)
aso.Mode=3
aso.Type=1
aso.Ouvrir
Fin du sous-marin
Sous-classe privée_Terminate
définir aso = rien
Fin du sous-marin
Fonction privée Bin2Str(Bin)
Dim I, Str
Pour I=1 à LenB(Bin)
clow=MidB(Bin,I,1)
si AscB(clow)<128 alors
Str = Str & Chr(ASCB(clow))
Autre
Je=Je+1
si I <= LenB(Bin) alors Str = Str & Chr(ASCW(MidB(Bin,I,1)&clow))
finSi
Suivant
Bin2Str = Chaîne
Fonction de fin
Fonction privée Num2Str(num,base,lens)
'GPS (2005-8-11)
faible ret
ret =
pendant que(num>=base)
ret = (numéro de base du mod) & ret
num = (num - num base du mod)/base
wend
Num2Str = droite (string (lens,0) & num & ret, lens)
Fonction de fin
Fonction privée Str2Num(str,base)
'GPS (2005-8-11)
faible ret
ret = 0
pour i=1 à len(str)
ret = ret *base + cint(mid(str,i,1))
suivant
NuméroStr2=ret
Fonction de fin
Fonction privée BinVal(bin)
'GPS (2002-8-11)
faible ret
ret = 0
pour i = lenb(bin) à 1 pas -1
ret = ret *256 + ascb(midb(bin,i,1))
suivant
BinVal=ret
Fonction de fin
Fonction privée BinVal2(bin)
'GPS (2002-8-11)
faible ret
ret = 0
pour i = 1 à lenb(bin)
ret = ret *256 + ascb(midb(bin,i,1))
suivant
BinVal2=ret
Fonction de fin
'///Ce qui suit est le code d'appel///
Fonction getImageSize (filespec)
'GPS (2002-8-11)
faible ret(3)
aso.LoadFromFile(filespec)
bFlag=aso.read(3)
sélectionner le cas hex(binVal(bFlag))
cas 4E5089 :
aso.read(15)
ret(0)=PNG
ret(1)=BinVal2(aso.read(2))
aso.read(2)
ret(2)=BinVal2(aso.read(2))
cas 464947 :
aso.read(3)
ret(0)=GIF
ret(1)=BinVal(aso.read(2))
ret(2)=BinVal(aso.read(2))
cas 535746 :
aso.read(5)
binData=aso.Read(1)
sConv=Num2Str(ascb(binData),2,8)
nBits=Str2Num(gauche(sConv,5),2)
sConv=milieu(sConv,6)
tandis que(len(sConv)<nBits*4)
binData=aso.Read(1)
sConv=sConv&Num2Str(ascb(binData),2,8)
wend
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)
cas FFD8FF :
faire
faire : p1=binVal(aso.Read(1)) : boucle while p1=255 et non aso.EOS
si p1>191 et p1<196 alors quittez, faites autrement aso.read(binval2(aso.Read(2))-2)
do:p1=binVal(aso.Read(1)):boucle while p1<255 et non aso.EOS
boucle tant que vrai
aso.Read(3)
ret(0)=JPG
ret(2)=binval2(aso.Read(2))
ret(1)=binval2(aso.Read(2))
cas sinon :
si gauche(Bin2Str(bFlag),2)=BM alors
aso.Lire(15)
ret(0)=BMP
ret(1)=binval(aso.Read(4))
ret(2)=binval(aso.Read(4))
autre
ret(0)=
finir si
fin de la sélection
ret(3)=largeur= & ret(1) & hauteur=
& retrait(2)&
getimagesize=ret
Fonction de fin
Fin du cours
%>
Copiez le code ci-dessus pour générer le fichier GPS.asp, afin que la classe générale permettant d'obtenir la taille de l'image sans composants soit correcte.
2. Obtenez le chemin de l'image
Puisqu'il y a plus d'une image et que les images doivent être stockées dans des catégories, nous avons conçu un champ ImgURL dans la base de données pour stocker le chemin relatif de l'image. Nous mettons toutes les images téléchargées dans un dossier appelé images (je n'entrerai pas dans les détails sur la façon de télécharger des images sans composants). Maintenant, nous concevons d’abord une page ShowImg.asp pour afficher des vignettes et des informations associées. La conception spécifique est la suivante :
image:
Format des images :
Taille de l'image :
Taille de l'image :
Nombre de clics :
Ensuite, nous obtenons le chemin absolu de l’image. Le code est le suivant :
<%
'/////Obtenir le chemin absolu de ShowImg.asp/////
Dim curFichier
curFile=Serveur.mappath(Request.servervariables(PATH_INFO))
Dim curfilename,filename
'/////Chemin relatif à l'image (stockée dans la base de données)
nom_fichier=rs(ImgURL)
'/////Parce que ShowImg.asp se trouve dans le même répertoire que les images, nous utilisons instrrev pour obtenir le chemin des images/////
filename=left(curFile,instrrev(curFile,/))&cufilename
'/////Créer une entité de classe GPS/////
Dim GetPicSize
Définir GetPicSize = nouveau GPS
Définir fs = Server.CreateObject (Scripting.FileSystemObject)
'/////Obtenir le type d'image/////
Dim PicSuffixName
PicSuffixName = fs.GetExtensionName (nom de fichier)
Dim PD '//Dimension de l'image
Dim PLargeur, PHHauteur
Sélectionnez le cas PicSuffixName
Cas gif,bmp,jpg,png :
'/////Appelez la fonction GetImageSize dans la classe générale GPS pour obtenir la taille de l'image/////
PD = GetPicSize.GetImageSize (nom de fichier)
PWidth=PD(1) '//Obtenir la largeur de l'image
PHeight=PD(2) '//Obtenir la hauteur de l'image
Cas swf
PD = GetPicSize.GetImageSize (nom de fichier)
PWidth=PD(1) '//Obtenir la largeur du Flash
PHeight=PD(2) '//Obtenir la hauteur du flash
Autre cas
Fin de la sélection
Définir fs=Rien
Définir GetPicSize=Rien
%>
Copiez le code ci-dessus en haut de <body> et c'est OK !
Bien sûr, certaines personnes diront que vous n'avez pas besoin d'utiliser PATH_INFO pour obtenir le chemin. Vous pouvez simplement utiliser server.mappath() directement, haha, chacun a ses propres préférences. La raison principale est que je peux utiliser PATH_INFO pour. réaliser certaines fonctions de FSO et utiliser le serveur. .mappath() n'a pas fonctionné, j'ai donc continué à l'utiliser.
3. Définir la taille des vignettes
Cette partie du code est dans l’œil du spectateur, et le sage voit la sagesse. Tout d'abord, nous devons spécifier la plage de taille d'affichage des vignettes, par exemple : 300X260. Le code peut être écrit comme ceci :
<%
Dim PXLargeur, PXHauteur
Dim Pp'//Proportion
Si PWidth=0 ou PWidth= Alors
LargeurPX=0
PXHauteur=0
Autre
Pp=FormatNumber(PWidth/PHeight,2) '//Rapport d'aspect
Fin si
Si PLargeur>=PHauteur Alors
Si PLargeur>=300 Alors
PXLargeur=300
PXHauteur=FormatNumber(300/Pp,0)
Autre
PXLargeur=PLargeur
PXHauteur=PHauteur
Fin si
Autre
Si PHauteur>=260 Alors
PXHauteur=260
PXLargeur=NuméroFormat(260*Pp,0)
Autre
PXLargeur=PLargeur
PXHauteur=PHauteur
Fin si
Fin si
%>
Écrivez simplement le code ci-dessus immédiatement après la deuxième étape. Le code lors de l'appel est le suivant :
<img src=<%=curfilename%> border=0 width=<%=PXWidth%>
hauteur=<%=PXHauteur%>>
Quant au format de l'image, vous pouvez utiliser <%=PicSuffixName%> pour l'obtenir, et la taille de l'image peut être écrite comme
<%
réponse.write PXWidth&X&PXHeight
%>
La taille de l'image peut être réalisée à l'aide de FSO.GetFileSize(filename), et le nombre de clics peut être simplement réalisé à l'aide d'instructions SQL. Le codage spécifique ne sera pas décrit à nouveau.
De cette façon, un programme de génération de vignettes sans composants a été écrit. Il est peut-être un peu emprunté, mais tant que tout le monde pourra maîtriser la méthode, je pense qu'elle sera grandement améliorée.