精华内容
下载资源
问答
  • 也就是下午4点拍的照片,Exif显示是凌晨4点。 好在欧洲大陆都用相同时区(偶没去过,不晓得,只是老爸说导游都是这样执行),每张都 +12H 即可。 基本各种照片查看工具都有批量修改功能,但无奈咱需要...
    老爸老妈去欧洲画了一个圈,带回来一千多张照片(数量没法和年轻人比)。

    虽然老爸晓得调节相机中的时间,但是毕竟年岁不饶人,整差了12个小时。

    也就是下午4点拍的照片,Exif里显示是凌晨4点。

    好在欧洲大陆都用相同的时区(偶没去过,不晓得,只是老爸说导游都是这样执行的),每张都 +12H 即可。

    基本各种照片查看工具都有批量修改功能,但无奈咱需要“时间+12H”确谁也没有。

    咋办?自己写段代码吧。

    由于用途单一,且是一锤子买卖,就没有“修饰”各种选项、配置,有需要的童鞋可以进一步完善。

    (代码是在以前写的一个查看Exif小程序的基础上写的,提供整个工程下载)


    DialogUtil openFolder = new DialogUtil();
    if (openFolder.ShowFolderDialog() == DialogResult.OK)
    {
    DirectoryInfo source = new DirectoryInfo(openFolder.Path);
    foreach (FileInfo fi in source.GetFiles("*.jpg"))
    {
    ExifManager exif = new ExifManager(fi.FullName);
    exif.DateTimeOriginal = exif.DateTimeOriginal.AddHours(12);
    exif.DateTimeDigitized = exif.DateTimeDigitized.AddHours(12);
    exif.Save(fi.DirectoryName + "\\new\\" + fi.Name);
    exif.Dispose();
    }
    }



    using System;
    using System.Collections.Generic;
    using System.Text;

    namespace ExifShow
    {
    //
    // Utility class for working with EXIF data in images. Provides abstraction
    // for most common data and generic utilities for work with all other.
    //
    //
    // Copyright (c) Michal A. Valášek - Altair Communications, 2003-2005
    // Copmany: http://software.altaircom.net, E-mail: support@altaircom.net
    // Private: http://www.rider.cz, E-mail: rider@rider.cz
    // This is free software licensed under GNU Lesser General Public License
    //
    //
    // [altair] 10.09.2003 Created
    // [altair] 12.06.2004 Added capability to write EXIF data
    // [altair] 11.07.2004 Added option to change encoding
    // [altair] 04.09.2005 Changed source of Width and Height properties from EXIF to image
    // [altair] 05.09.2005 Code clean-up and minor changes
    // [marco.ridoni@virgilio.it] 02-11-2006 C# translation
    //
    public class ExifManager : IDisposable
    {

    private System.Drawing.Bitmap _Image;
    private System.Text.Encoding _Encoding = System.Text.Encoding.UTF8;

    #region Type declarations

    //
    // Contains possible values of EXIF tag names (ID)
    //
    // See GdiPlusImaging.h
    //
    // [altair] 10.09.2003 Created
    //

    public enum TagNames : int
    {
    ExifIFD = 0x8769,
    GpsIFD = 0x8825,
    NewSubfileType = 0xFE,
    SubfileType = 0xFF,
    ImageWidth = 0x100,
    ImageHeight = 0x101,
    BitsPerSample = 0x102,
    Compression = 0x103,
    PhotometricInterp = 0x106,
    ThreshHolding = 0x107,
    CellWidth = 0x108,
    CellHeight = 0x109,
    FillOrder = 0x10A,
    DocumentName = 0x10D,
    ImageDescription = 0x10E,
    EquipMake = 0x10F,
    EquipModel = 0x110,
    StripOffsets = 0x111,
    Orientation = 0x112,
    SamplesPerPixel = 0x115,
    RowsPerStrip = 0x116,
    StripBytesCount = 0x117,
    MinSampleValue = 0x118,
    MaxSampleValue = 0x119,
    XResolution = 0x11A,
    YResolution = 0x11B,
    PlanarConfig = 0x11C,
    PageName = 0x11D,
    XPosition = 0x11E,
    YPosition = 0x11F,
    FreeOffset = 0x120,
    FreeByteCounts = 0x121,
    GrayResponseUnit = 0x122,
    GrayResponseCurve = 0x123,
    T4Option = 0x124,
    T6Option = 0x125,
    ResolutionUnit = 0x128,
    PageNumber = 0x129,
    TransferFuncition = 0x12D,
    SoftwareUsed = 0x131,
    DateTime = 0x132,
    Artist = 0x13B,
    HostComputer = 0x13C,
    Predictor = 0x13D,
    WhitePoint = 0x13E,
    PrimaryChromaticities = 0x13F,
    ColorMap = 0x140,
    HalftoneHints = 0x141,
    TileWidth = 0x142,
    TileLength = 0x143,
    TileOffset = 0x144,
    TileByteCounts = 0x145,
    InkSet = 0x14C,
    InkNames = 0x14D,
    NumberOfInks = 0x14E,
    DotRange = 0x150,
    TargetPrinter = 0x151,
    ExtraSamples = 0x152,
    SampleFormat = 0x153,
    SMinSampleValue = 0x154,
    SMaxSampleValue = 0x155,
    TransferRange = 0x156,
    JPEGProc = 0x200,
    JPEGInterFormat = 0x201,
    JPEGInterLength = 0x202,
    JPEGRestartInterval = 0x203,
    JPEGLosslessPredictors = 0x205,
    JPEGPointTransforms = 0x206,
    JPEGQTables = 0x207,
    JPEGDCTables = 0x208,
    JPEGACTables = 0x209,
    YCbCrCoefficients = 0x211,
    YCbCrSubsampling = 0x212,
    YCbCrPositioning = 0x213,
    REFBlackWhite = 0x214,
    ICCProfile = 0x8773,
    Gamma = 0x301,
    ICCProfileDescriptor = 0x302,
    SRGBRenderingIntent = 0x303,
    ImageTitle = 0x320,
    Copyright = 0x8298,
    ResolutionXUnit = 0x5001,
    ResolutionYUnit = 0x5002,
    ResolutionXLengthUnit = 0x5003,
    ResolutionYLengthUnit = 0x5004,
    PrintFlags = 0x5005,
    PrintFlagsVersion = 0x5006,
    PrintFlagsCrop = 0x5007,
    PrintFlagsBleedWidth = 0x5008,
    PrintFlagsBleedWidthScale = 0x5009,
    HalftoneLPI = 0x500A,
    HalftoneLPIUnit = 0x500B,
    HalftoneDegree = 0x500C,
    HalftoneShape = 0x500D,
    HalftoneMisc = 0x500E,
    HalftoneScreen = 0x500F,
    JPEGQuality = 0x5010,
    GridSize = 0x5011,
    ThumbnailFormat = 0x5012,
    ThumbnailWidth = 0x5013,
    ThumbnailHeight = 0x5014,
    ThumbnailColorDepth = 0x5015,
    ThumbnailPlanes = 0x5016,
    ThumbnailRawBytes = 0x5017,
    ThumbnailSize = 0x5018,
    ThumbnailCompressedSize = 0x5019,
    ColorTransferFunction = 0x501A,
    ThumbnailData = 0x501B,
    ThumbnailImageWidth = 0x5020,
    ThumbnailImageHeight = 0x502,
    ThumbnailBitsPerSample = 0x5022,
    ThumbnailCompression = 0x5023,
    ThumbnailPhotometricInterp = 0x5024,
    ThumbnailImageDescription = 0x5025,
    ThumbnailEquipMake = 0x5026,
    ThumbnailEquipModel = 0x5027,
    ThumbnailStripOffsets = 0x5028,
    ThumbnailOrientation = 0x5029,
    ThumbnailSamplesPerPixel = 0x502A,
    ThumbnailRowsPerStrip = 0x502B,
    ThumbnailStripBytesCount = 0x502C,
    ThumbnailResolutionX = 0x502D,
    ThumbnailResolutionY = 0x502E,
    ThumbnailPlanarConfig = 0x502F,
    ThumbnailResolutionUnit = 0x5030,
    ThumbnailTransferFunction = 0x5031,
    ThumbnailSoftwareUsed = 0x5032,
    ThumbnailDateTime = 0x5033,
    ThumbnailArtist = 0x5034,
    ThumbnailWhitePoint = 0x5035,
    ThumbnailPrimaryChromaticities = 0x5036,
    ThumbnailYCbCrCoefficients = 0x5037,
    ThumbnailYCbCrSubsampling = 0x5038,
    ThumbnailYCbCrPositioning = 0x5039,
    ThumbnailRefBlackWhite = 0x503A,
    ThumbnailCopyRight = 0x503B,
    LuminanceTable = 0x5090,
    ChrominanceTable = 0x5091,
    FrameDelay = 0x5100,
    LoopCount = 0x5101,
    PixelUnit = 0x5110,
    PixelPerUnitX = 0x5111,
    PixelPerUnitY = 0x5112,
    PaletteHistogram = 0x5113,
    ExifExposureTime = 0x829A,
    ExifFNumber = 0x829D,
    ExifExposureProg = 0x8822,
    ExifSpectralSense = 0x8824,
    ExifISOSpeed = 0x8827,
    ExifOECF = 0x8828,
    ExifVer = 0x9000,
    ExifDTOrig = 0x9003,
    ExifDTDigitized = 0x9004,
    ExifCompConfig = 0x9101,
    ExifCompBPP = 0x9102,
    ExifShutterSpeed = 0x9201,
    ExifAperture = 0x9202,
    ExifBrightness = 0x9203,
    ExifExposureBias = 0x9204,
    ExifMaxAperture = 0x9205,
    ExifSubjectDist = 0x9206,
    ExifMeteringMode = 0x9207,
    ExifLightSource = 0x9208,
    ExifFlash = 0x9209,
    ExifFocalLength = 0x920A,
    ExifMakerNote = 0x927C,
    ExifUserComment = 0x9286,
    ExifDTSubsec = 0x9290,
    ExifDTOrigSS = 0x9291,
    ExifDTDigSS = 0x9292,
    ExifFPXVer = 0xA000,
    ExifColorSpace = 0xA001,
    ExifPixXDim = 0xA002,
    ExifPixYDim = 0xA003,
    ExifRelatedWav = 0xA004,
    ExifInterop = 0xA005,
    ExifFlashEnergy = 0xA20B,
    ExifSpatialFR = 0xA20C,
    ExifFocalXRes = 0xA20E,
    ExifFocalYRes = 0xA20F,
    ExifFocalResUnit = 0xA210,
    ExifSubjectLoc = 0xA214,
    ExifExposureIndex = 0xA215,
    ExifSensingMethod = 0xA217,
    ExifFileSource = 0xA300,
    ExifSceneType = 0xA301,
    ExifCfaPattern = 0xA302,
    GpsVer = 0x0,
    GpsLatitudeRef = 0x1,
    GpsLatitude = 0x2,
    GpsLongitudeRef = 0x3,
    GpsLongitude = 0x4,
    GpsAltitudeRef = 0x5,
    GpsAltitude = 0x6,
    GpsGpsTime = 0x7,
    GpsGpsSatellites = 0x8,
    GpsGpsStatus = 0x9,
    GpsGpsMeasureMode = 0xA,
    GpsGpsDop = 0xB,
    GpsSpeedRef = 0xC,
    GpsSpeed = 0xD,
    GpsTrackRef = 0xE,
    GpsTrack = 0xF,
    GpsImgDirRef = 0x10,
    GpsImgDir = 0x11,
    GpsMapDatum = 0x12,
    GpsDestLatRef = 0x13,
    GpsDestLat = 0x14,
    GpsDestLongRef = 0x15,
    GpsDestLong = 0x16,
    GpsDestBearRef = 0x17,
    GpsDestBear = 0x18,
    GpsDestDistRef = 0x19,
    GpsDestDist = 0x1A
    }


    //
    // Real position of 0th row and column of picture
    //
    //
    //
    // [altair] 10.09.2003 Created
    //

    public enum Orientations
    {
    TopLeft = 1,
    TopRight = 2,
    BottomRight = 3,
    BottomLeft = 4,
    LeftTop = 5,
    RightTop = 6,
    RightBottom = 7,
    LftBottom = 8
    }


    //
    // Exposure programs
    //
    //
    //
    // [altair] 10.09.2003 Created
    //

    public enum ExposurePrograms
    {
    Manual = 1,
    Normal = 2,
    AperturePriority = 3,
    ShutterPriority = 4,
    Creative = 5,
    Action = 6,
    Portrait = 7,
    Landscape = 8,
    }


    //
    // Exposure metering modes
    //
    //
    //
    // [altair] 10.09.2003 Created
    //

    public enum ExposureMeteringModes
    {
    Unknown = 0,
    Average = 1,
    CenterWeightedAverage = 2,
    Spot = 3,
    MultiSpot = 4,
    MultiSegment = 5,
    Partial = 6,
    Other = 255
    }


    //
    // Flash activity modes
    //
    //
    //
    // [altair] 10.09.2003 Created
    //

    public enum FlashModes
    {
    NotFired = 0,
    Fired = 1,
    FiredButNoStrobeReturned = 5,
    FiredAndStrobeReturned = 7,
    }


    //
    // Possible light sources (white balance)
    //
    //
    //
    // [altair] 10.09.2003 Created
    //

    public enum LightSources
    {
    Unknown = 0,
    Daylight = 1,
    Fluorescent = 2,
    Tungsten = 3,
    Flash = 10,
    StandardLightA = 17,
    StandardLightB = 18,
    StandardLightC = 19,
    D55 = 20,
    D65 = 21,
    D75 = 22,
    Other = 255
    }


    //
    // EXIF data types
    //
    //
    //
    // [altair] 12.6.2004 Created
    //
    public enum ExifDataTypes : short
    {
    UnsignedByte = 1,
    AsciiString = 2,
    UnsignedShort = 3,
    UnsignedLong = 4,
    UnsignedRational = 5,
    SignedByte = 6,
    Undefined = 7,
    SignedShort = 8,
    SignedLong = 9,
    SignedRational = 10,
    SingleFloat = 11,
    DoubleFloat = 12
    }


    //
    // Represents rational which is type of some Exif properties
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public struct Rational
    {
    public Int32 Numerator;
    public Int32 Denominator;


    //
    // Converts rational to string representation
    //
    // Optional, default "/". String to be used as delimiter of components.
    // String representation of the rational.
    //
    //
    // [altair] 10.09.2003 Created
    //

    public override string ToString()
    {
    return ToString("/");
    }

    public string ToString(string Delimiter)
    {
    return Numerator + "/" + Denominator;
    }

    //
    // Converts rational to double precision real number
    //
    // The rational as double precision real number.
    //
    //
    // [altair] 10.09.2003 Created
    //

    public double ToDouble()
    {
    return (double)Numerator / Denominator;
    }
    }

    #endregion

    //
    // Initializes new instance of this class.
    //
    // Bitmap to read exif information from
    //
    //
    // [altair] 10.09.2003 Created
    //
    public ExifManager(System.Drawing.Bitmap Bitmap)
    {
    if (Bitmap == null)
    throw new ArgumentNullException("Bitmap");
    this._Image = Bitmap;
    }

    //
    // Initializes new instance of this class.
    //
    // Name of file to be loaded
    //
    //
    // [altair] 13.06.2004 Created
    //
    public ExifManager(string FileName)
    {
    this._Image = (System.Drawing.Bitmap)System.Drawing.Bitmap.FromFile(FileName);
    }

    //
    // Get or set encoding used for string metadata
    //
    // Encoding used for string metadata
    // Default encoding is UTF-8
    //
    // [altair] 11.07.2004 Created
    // [altair] 05.09.2005 Changed from shared to instance member
    //
    public System.Text.Encoding Encoding
    {
    get
    {
    return this._Encoding;
    }
    set
    {
    if (value == null)
    throw new ArgumentNullException();
    this._Encoding = value;
    }
    }

    //
    // Returns copy of bitmap this instance is working on
    //
    //
    //
    //
    // [altair] 13.06.2004 Created
    //
    public System.Drawing.Bitmap GetBitmap()
    {
    return (System.Drawing.Bitmap)this._Image.Clone();
    }

    //
    // Returns all available data in formatted string form
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public override string ToString()
    {
    System.Text.StringBuilder SB = new StringBuilder();

    SB.Append("照片信息:");
    SB.Append("\n\t尺寸: " + this.Width + " x " + this.Height + " px");
    SB.Append("\n\t分辨率: " + this.ResolutionX + " x " + this.ResolutionY + " dpi");
    SB.Append("\n\t方向: " + Enum.GetName(typeof(Orientations), this.Orientation));
    SB.Append("\n\t标题: " + this.Title);
    SB.Append("\n\t描述: " + this.Description);
    SB.Append("\n\t作者: " + this.Artist);
    SB.Append("\n\t版权信息: " + this.Copyright);
    SB.Append("\n相机信息:");
    SB.Append("\n\t制造商: " + this.EquipmentMaker);
    SB.Append("\n\t型号: " + this.EquipmentModel);
    SB.Append("\n\t编辑软件: " + this.Software);
    SB.Append("\n时间信息:");
    SB.Append("\n\t最后编辑时间: " + this.DateTimeLastModified.ToString());
    SB.Append("\n\t原始拍照时间: " + this.DateTimeOriginal.ToString());
    SB.Append("\n\t数字化时间: " + this.DateTimeDigitized.ToString());
    SB.Append("\n拍摄信息:");
    SB.Append("\n\t曝光时间: " + this.ExposureTime.ToString("N4") + " s");
    SB.Append("\n\t曝光模式: " + Enum.GetName(typeof(ExposurePrograms), this.ExposureProgram));
    SB.Append("\n\t测光模式: " + Enum.GetName(typeof(ExposureMeteringModes), this.ExposureMeteringMode));
    SB.Append("\n\t光圈值: F" + this.Aperture.ToString("N1"));
    SB.Append("\n\tISO感光度: " + this.ISO);
    SB.Append("\n\t拍摄距离: " + this.SubjectDistance.ToString("N2") + " m");
    SB.Append("\n\t焦距: " + this.FocalLength + " mm");
    SB.Append("\n\t闪光灯: " + Enum.GetName(typeof(FlashModes), this.FlashMode));
    SB.Append("\n\t白平衡(WB): " + Enum.GetName(typeof(LightSources), this.LightSource));
    //SB.Replace("\n", vbCrLf);
    //SB.Replace("\t", vbTab);
    return SB.ToString();
    }

    #region Nicely formatted well-known properties

    //
    // Brand of equipment (EXIF EquipMake)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public string EquipmentMaker
    {
    get
    {
    return this.GetPropertyString((int)TagNames.EquipMake);
    }
    }

    //
    // Model of equipment (EXIF EquipModel)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public string EquipmentModel
    {
    get
    {
    return this.GetPropertyString((int)TagNames.EquipModel);
    }
    }

    //
    // Software used for processing (EXIF Software)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public string Software
    {
    get
    {
    return this.GetPropertyString((int)TagNames.SoftwareUsed);
    }
    }

    //
    // Orientation of image (position of row 0, column 0) (EXIF Orientation)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public Orientations Orientation
    {
    get
    {
    Int32 X = this.GetPropertyInt16((int)TagNames.Orientation);

    if (!Enum.IsDefined(typeof(Orientations), X))
    return Orientations.TopLeft;
    else
    return (Orientations)Enum.Parse(typeof(Orientations), Enum.GetName(typeof(Orientations), X));
    }
    }

    //
    // Time when image was last modified (EXIF DateTime).
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public DateTime DateTimeLastModified
    {
    get
    {
    try
    {
    return DateTime.ParseExact(this.GetPropertyString((int)TagNames.DateTime), @"yyyy\:MM\:dd HH\:mm\:ss", null);
    }
    catch
    {
    return DateTime.MinValue;
    }
    }
    set
    {
    try
    {
    this.SetPropertyString((int)TagNames.DateTime, value.ToString(@"yyyy\:MM\:dd HH\:mm\:ss"));
    }
    catch
    { }
    }
    }

    //
    // Time when image was taken (EXIF DateTimeOriginal).
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public DateTime DateTimeOriginal
    {
    get
    {
    try
    {
    return DateTime.ParseExact(this.GetPropertyString((int)TagNames.ExifDTOrig), @"yyyy\:MM\:dd HH\:mm\:ss", null);
    }
    catch
    {
    return DateTime.MinValue;
    }
    }
    set
    {
    try
    {
    this.SetPropertyString((int)TagNames.ExifDTOrig, value.ToString(@"yyyy\:MM\:dd HH\:mm\:ss"));
    }
    catch
    { }
    }
    }

    //
    // Time when image was digitized (EXIF DateTimeDigitized).
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public DateTime DateTimeDigitized
    {
    get
    {
    try
    {
    return DateTime.ParseExact(this.GetPropertyString((int)TagNames.ExifDTDigitized), @"yyyy\:MM\:dd HH\:mm\:ss", null);
    }
    catch
    {
    return DateTime.MinValue;
    }
    }
    set
    {
    try
    {
    this.SetPropertyString((int)TagNames.ExifDTDigitized, value.ToString(@"yyyy\:MM\:dd HH\:mm\:ss"));
    }
    catch
    { }
    }
    }

    //
    // Image width
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    // [altair] 04.09.2005 Changed output to Int32, load from image instead of EXIF
    //
    public Int32 Width
    {
    get { return this._Image.Width; }
    }

    //
    // Image height
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    // [altair] 04.09.2005 Changed output to Int32, load from image instead of EXIF
    //
    public Int32 Height
    {
    get { return this._Image.Height; }
    }

    //
    // X resolution in dpi (EXIF XResolution/ResolutionUnit)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public double ResolutionX
    {
    get
    {
    double R = this.GetPropertyRational((int)TagNames.XResolution).ToDouble();

    if (this.GetPropertyInt16((int)TagNames.ResolutionUnit) == 3)
    {
    // -- resolution is in points/cm
    return R * 2.54;
    }
    else
    {
    // -- resolution is in points/inch
    return R;
    }
    }
    }

    //
    // Y resolution in dpi (EXIF YResolution/ResolutionUnit)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public double ResolutionY
    {
    get
    {
    double R = this.GetPropertyRational((int)TagNames.YResolution).ToDouble();

    if (this.GetPropertyInt16((int)TagNames.ResolutionUnit) == 3)
    {
    // -- resolution is in points/cm
    return R * 2.54;
    }
    else
    {
    // -- resolution is in points/inch
    return R;
    }
    }
    }

    //
    // Image title (EXIF ImageTitle)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public string Title
    {
    get
    {
    return this.GetPropertyString((int)TagNames.ImageTitle);
    }
    set
    {
    try
    {
    this.SetPropertyString((int)TagNames.ImageTitle, value);
    }
    catch { }
    }
    }

    //
    // User comment (EXIF UserComment)
    //
    //
    //
    //
    // [altair] 13.06.2004 Created
    //
    public string UserComment
    {
    get
    {
    return this.GetPropertyString((int)TagNames.ExifUserComment);
    }
    set
    {
    try
    {
    this.SetPropertyString((int)TagNames.ExifUserComment, value);
    }
    catch { }
    }
    }

    //
    // Artist name (EXIF Artist)
    //
    //
    //
    //
    // [altair] 13.06.2004 Created
    //
    public string Artist
    {
    get
    {
    return this.GetPropertyString((int)TagNames.Artist);
    }
    set
    {
    try
    {
    this.SetPropertyString((int)TagNames.Artist, value);
    }
    catch { }
    }
    }

    //
    // Image description (EXIF ImageDescription)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public string Description
    {
    get
    {
    return this.GetPropertyString((int)TagNames.ImageDescription);
    }
    set
    {
    try
    {
    this.SetPropertyString((int)TagNames.ImageDescription, value);
    }
    catch { }
    }
    }

    //
    // Image copyright (EXIF Copyright)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public string Copyright
    {
    get
    {
    return this.GetPropertyString((int)TagNames.Copyright);
    }
    set
    {
    try
    {
    this.SetPropertyString((int)TagNames.Copyright, value);
    }
    catch { }
    }
    }


    //
    // Exposure time in seconds (EXIF ExifExposureTime/ExifShutterSpeed)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public double ExposureTimeAbs
    {
    get
    {
    if (this.IsPropertyDefined((int)TagNames.ExifExposureTime))
    // -- Exposure time is explicitly specified
    return this.GetPropertyRational((int)TagNames.ExifExposureTime).ToDouble();
    else
    if (this.IsPropertyDefined((int)TagNames.ExifShutterSpeed))
    //'-- Compute exposure time from shutter spee
    return (1 / Math.Pow(2, this.GetPropertyRational((int)TagNames.ExifShutterSpeed).ToDouble()));
    else
    // -- Can't figure out
    return 0;
    }
    }

    public Rational ExposureTime
    {
    get
    {
    if (this.IsPropertyDefined((int)TagNames.ExifExposureTime))
    // -- Exposure time is explicitly specified
    return this.GetPropertyRational((int)TagNames.ExifExposureTime);
    else
    return new Rational();
    }
    }

    //
    // Aperture value as F number (EXIF ExifFNumber/ExifApertureValue)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public double Aperture
    {
    get
    {
    if (this.IsPropertyDefined((int)TagNames.ExifFNumber))
    return this.GetPropertyRational((int)TagNames.ExifFNumber).ToDouble();
    else
    if (this.IsPropertyDefined((int)TagNames.ExifAperture))
    return Math.Pow(System.Math.Sqrt(2), this.GetPropertyRational((int)TagNames.ExifAperture).ToDouble());
    else
    return 0;
    }
    }

    //
    // Exposure program used (EXIF ExifExposureProg)
    //
    //
    // If not specified, returns Normal (2)
    //
    // [altair] 10.09.2003 Created
    //
    public ExposurePrograms ExposureProgram
    {
    get
    {
    Int32 X = this.GetPropertyInt16((int)TagNames.ExifExposureProg);

    if (Enum.IsDefined(typeof(ExposurePrograms), X))
    return (ExposurePrograms)Enum.Parse(typeof(ExposurePrograms), Enum.GetName(typeof(ExposurePrograms), X));
    else
    return ExposurePrograms.Normal;
    }
    }

    //
    // ISO sensitivity
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public Int16 ISO
    {
    get { return this.GetPropertyInt16((int)TagNames.ExifISOSpeed); }
    }

    //
    // Subject distance in meters (EXIF SubjectDistance)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public double SubjectDistance
    {
    get { return this.GetPropertyRational((int)TagNames.ExifSubjectDist).ToDouble(); }
    }

    //
    // Exposure method metering mode used (EXIF MeteringMode)
    //
    //
    // If not specified, returns Unknown (0)
    //
    // [altair] 10.09.2003 Created
    //
    public ExposureMeteringModes ExposureMeteringMode
    {
    get
    {
    Int32 X = this.GetPropertyInt16((int)TagNames.ExifMeteringMode);

    if (Enum.IsDefined(typeof(ExposureMeteringModes), X))
    return (ExposureMeteringModes)Enum.Parse(typeof(ExposureMeteringModes), Enum.GetName(typeof(ExposureMeteringModes), X));
    else
    return ExposureMeteringModes.Unknown;
    }
    }

    //
    // Focal length of lenses in mm (EXIF FocalLength)
    //
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public double FocalLength
    {
    get { return this.GetPropertyRational((int)TagNames.ExifFocalLength).ToDouble(); }
    }

    //
    // Flash mode (EXIF Flash)
    //
    //
    // If not present, value NotFired (0) is returned
    //
    // [altair] 10.09.2003 Created
    //
    public FlashModes FlashMode
    {
    get
    {
    Int32 X = this.GetPropertyInt16((int)TagNames.ExifFlash);

    if (Enum.IsDefined(typeof(FlashModes), X))
    return (FlashModes)Enum.Parse(typeof(FlashModes), Enum.GetName(typeof(FlashModes), X));
    else
    return FlashModes.NotFired;
    }
    }

    //
    // Light source / white balance (EXIF LightSource)
    //
    //
    // If not specified, returns Unknown (0).
    //
    // [altair] 10.09.2003 Created
    //
    public LightSources LightSource
    {
    get
    {
    Int32 X = this.GetPropertyInt16((int)TagNames.ExifLightSource);

    if (Enum.IsDefined(typeof(LightSources), X))
    return (LightSources)Enum.Parse(typeof(LightSources), Enum.GetName(typeof(LightSources), X));
    else
    return LightSources.Unknown;
    }
    }

    #endregion

    #region Support methods for working with EXIF properties

    //
    // Checks if current image has specified certain property
    //
    //
    // True if image has specified property, False otherwise.
    //
    //
    // [altair] 10.09.2003 Created
    //
    public bool IsPropertyDefined(Int32 PID)
    {
    return (Array.IndexOf(this._Image.PropertyIdList, PID) > -1);
    }

    //
    // Gets specified Int32 property
    //
    // Property ID
    // Optional, default 0. Default value returned if property is not present.
    // Value of property or DefaultValue if property is not present.
    //
    //
    // [altair] 10.09.2003 Created
    //
    public Int32 GetPropertyInt32(Int32 PID)
    {
    return GetPropertyInt32(PID, 0);
    }

    public Int32 GetPropertyInt32(Int32 PID, Int32 DefaultValue)
    {
    if (IsPropertyDefined(PID))
    return GetInt32(this._Image.GetPropertyItem(PID).Value);
    else
    return DefaultValue;
    }

    //
    // Gets specified Int16 property
    //
    // Property ID
    // Optional, default 0. Default value returned if property is not present.
    // Value of property or DefaultValue if property is not present.
    //
    //
    // [altair] 10.09.2003 Created
    //
    public Int16 GetPropertyInt16(Int32 PID)
    {
    return GetPropertyInt16(PID, 0);
    }

    public Int16 GetPropertyInt16(Int32 PID, Int16 DefaultValue)
    {
    if (IsPropertyDefined(PID))
    return GetInt16(this._Image.GetPropertyItem(PID).Value);
    else
    return DefaultValue;
    }

    //
    // Gets specified string property
    //
    // Property ID
    // Optional, default String.Empty. Default value returned if property is not present.
    //
    // Value of property or DefaultValue if property is not present.
    //
    // [altair] 10.09.2003 Created
    //
    public string GetPropertyString(Int32 PID)
    {
    return GetPropertyString(PID, "");
    }

    public string GetPropertyString(Int32 PID, string DefaultValue)
    {
    if (IsPropertyDefined(PID))
    return GetString(this._Image.GetPropertyItem(PID).Value);
    else
    return DefaultValue;
    }

    //
    // Gets specified property in raw form
    //
    // Property ID
    // Optional, default Nothing. Default value returned if property is not present.
    //
    // Is recommended to use typed methods (like etc.) instead, when possible.
    //
    // [altair] 05.09.2005 Created
    //
    public byte[] GetProperty(Int32 PID, byte[] DefaultValue)
    {
    if (IsPropertyDefined(PID))
    return this._Image.GetPropertyItem(PID).Value;
    else
    return DefaultValue;
    }

    public byte[] GetProperty(Int32 PID)
    {
    return GetProperty(PID, null);
    }

    //
    // Gets specified rational property
    //
    // Property ID
    //
    // Value of property or 0/1 if not present.
    //
    // [altair] 10.09.2003 Created
    //
    public Rational GetPropertyRational(Int32 PID)
    {
    if (IsPropertyDefined(PID))
    return GetRational(this._Image.GetPropertyItem(PID).Value);
    else
    {
    Rational R;
    R.Numerator = 0;
    R.Denominator = 1;
    return R;
    }
    }

    //
    // Sets specified string property
    //
    // Property ID
    // Value to be set
    //
    //
    // [altair] 12.6.2004 Created
    //
    public void SetPropertyString(Int32 PID, string Value)
    {
    byte[] Data = this._Encoding.GetBytes(Value + '\0');
    SetProperty(PID, Data, ExifDataTypes.AsciiString);
    }

    //
    // Sets specified Int16 property
    //
    // Property ID
    // Value to be set
    //
    //
    // [altair] 12.6.2004 Created
    //
    public void SetPropertyInt16(Int32 PID, Int16 Value)
    {
    byte[] Data = new byte[2];
    Data[0] = (byte)(Value & 0xFF);
    Data[1] = (byte)((Value & 0xFF00) >> 8);
    SetProperty(PID, Data, ExifDataTypes.SignedShort);
    }

    //
    // Sets specified Int32 property
    //
    // Property ID
    // Value to be set
    //
    //
    // [altair] 13.06.2004 Created
    //
    public void SetPropertyInt32(Int32 PID, Int32 Value)
    {
    byte[] Data = new byte[4];
    for (int I = 0; I < 4; I++)
    {
    Data[I] = (byte)(Value & 0xFF);
    Value >>= 8;
    }
    SetProperty(PID, Data, ExifDataTypes.SignedLong);
    }

    //
    // Sets specified property in raw form
    //
    // Property ID
    // Raw data
    // EXIF data type
    // Is recommended to use typed methods (like etc.) instead, when possible.
    //
    // [altair] 12.6.2004 Created
    //
    public void SetProperty(Int32 PID, byte[] Data, ExifDataTypes Type)
    {
    System.Drawing.Imaging.PropertyItem P = this._Image.PropertyItems[0];
    P.Id = PID;
    P.Value = Data;
    P.Type = (Int16)Type;
    P.Len = Data.Length;
    this._Image.SetPropertyItem(P);
    }

    //
    // Reads Int32 from EXIF bytearray.
    //
    // EXIF bytearray to process
    //
    //
    //
    // [altair] 10.09.2003 Created
    // [altair] 05.09.2005 Changed from public shared to private instance method
    //
    private Int32 GetInt32(byte[] B)
    {
    if (B.Length < 4)
    throw new ArgumentException("Data too short (4 bytes expected)", "B");

    return B[3] << 24 | B[2] << 16 | B[1] << 8 | B[0];
    }

    //
    // Reads Int16 from EXIF bytearray.
    //
    // EXIF bytearray to process
    //
    //
    //
    // [altair] 10.09.2003 Created
    // [altair] 05.09.2005 Changed from public shared to private instance method
    //
    private Int16 GetInt16(byte[] B)
    {
    if (B.Length < 2)
    throw new ArgumentException("Data too short (2 bytes expected)", "B");

    return (short)(B[1] << 8 | B[0]);
    }

    //
    // Reads string from EXIF bytearray.
    //
    // EXIF bytearray to process
    //
    //
    //
    // [altair] 10.09.2003 Created
    // [altair] 05.09.2005 Changed from public shared to private instance method
    //
    private string GetString(byte[] B)
    {
    string R = this._Encoding.GetString(B);
    if (R.EndsWith("\0"))
    R = R.Substring(0, R.Length - 1);
    return R;
    }

    //
    // Reads rational from EXIF bytearray.
    //
    // EXIF bytearray to process
    //
    //
    //
    // [altair] 10.09.2003 Created
    // [altair] 05.09.2005 Changed from public shared to private instance method
    //
    private Rational GetRational(byte[] B)
    {
    Rational R = new Rational();
    byte[] N = new byte[4];
    byte[] D = new byte[4];
    Array.Copy(B, 0, N, 0, 4);
    Array.Copy(B, 4, D, 0, 4);
    R.Denominator = this.GetInt32(D);
    R.Numerator = this.GetInt32(N);
    return R;
    }

    public void Save(string fileName){
    this._Image.Save(fileName);
    }
    #endregion

    #region " IDisposable implementation "

    //
    // Disposes unmanaged resources of this class
    //
    //
    //
    // [altair] 10.09.2003 Created
    //
    public void Dispose()
    {
    this._Image.Dispose();
    }

    #endregion

    }
    }



    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Windows.Forms;
    using System.Windows.Forms.Design;

    /**
    * 对话框工具
    *
    * @author LianTao
    * @version 1.0 2008.11.01
    */
    namespace Utils
    {
    public class DialogUtil : FolderNameEditor
    {
    FolderNameEditor.FolderBrowser fDialog = new
    System.Windows.Forms.Design.FolderNameEditor.FolderBrowser();

    /**
    * 构造函数
    */
    public DialogUtil()
    {
    }

    /**
    * 打开“浏览”对话框
    */
    public DialogResult ShowFolderDialog()
    {
    return ShowFolderDialog("请选择一个文件夹");
    }

    /**
    * 打开“浏览”对话框
    *
    * @param description
    * 对话框的标题
    */
    public DialogResult ShowFolderDialog(string description)
    {
    fDialog.Description = description;
    fDialog.StartLocation = FolderBrowserFolder.Desktop;
    return fDialog.ShowDialog();
    }
    ~DialogUtil()
    {
    fDialog.Dispose();
    }
    }

    展开全文
  • 工具下载地址在文章最末尾。今年8月份的时候,我在公众号发过一个文章...实际上我在zip包里的README.md里已经写了关于如何使用的文档,但是,对于有些来说,命令行不是那么容易掌握。没错,折腾了半个...

    工具下载地址在文章最末尾。

    今年8月份的时候,我在公众号发过一个文章《qBittorrent如何如何批量修改tracker地址》,那时候提供的是命令行工具。

    近期有几大批踢站都改了官方tracker地址,然后,有一天,我刚好在群里,看到有人在问这个命令怎么使用。

    实际上我在zip包里的README.md里已经写了关于如何使用的文档,但是,对于有些人来说,命令行不是那么容易掌握。

    没错,折腾了半个小时,群里的这位童鞋才最终搞定这个。

    其实在当初发布命令行工具的时候,我就已经考虑过,是不是要添加一个图形界面?

    但是一直没空,所以暂时也就搁置了。

    而最近这些大站修改tracker, 我想还是要想办法改进一下这个工具。

    使它更容易使用一些。

    所以,就有了现在版本的带WEB UI的一键工具。

    此工具具有以下特点:

    1. 基于qb 自带的web API实现,安全无副作用,可以在线实时更新生效

    2. 同时支持web UI操作和命令行的方式操作,兼顾不同的使用人群

    3. 实时显示操作结果,每个种子的修改结果无论成功还是失败,都会详细地显示,让一切尽在掌握之中,而不是令人不知道发生了什么事情

    4. 同时支持64位的Linux, Mac OS X, Windows以及arm64 Linux

    由于是多系统支持的,因此打包在一个zip文件中,解压后文件如下:

    2cddf15bec5319918a489f6a6b8ae27b.png


    如何打开WEB UI 界面?

    直接执行程序,会默认自动打开WEB UI:  http://127.0.0.1:8888

    (如果没有自动打开,说明你的操作系统太古老,自己手动打开下)

    WEB UI界面效果图:

    63dbb5a74c026899e83ee82caaf37214.png

    命令行使用方法

    以Linux AMD64为例:

    (其它平台请自行替换下面相应的文件名, 比如windows要将./qb-tracker-update-bulk.amd64  换成  qb-tracker-update-bulk.amd64.exe )

    查看此程序的版本信息:

    ❯ ./qb-tracker-update-bulk.amd64 -ver
    Built at
        2019-12-12T02:02:46+0800
    Git revision
        078793d
    Git branch
        master
    Go version
        go1.13.4

    查看帮助信息:

    ❯ ./qb-tracker-update-bulk.amd64 --help
    Usage of ./qb-tracker-update-bulk.amd64:
      -a string
            qBittorrent WEB UI URL, this is the same as login URL (default "http://127.0.0.1:8080")
      -cli
            do not start the WEB UI and use the command version
      -i    get qBittorrent version info and exit
      -new string
            New Tracker URL to replace the Old Tracker URL
      -orig string
            Old Tracker URL you want to edit
      -p string
            qBittorrent WEB UI login password if needed
      -u string
            qBittorrent WEB UI login username if needed
      -ver
            print this tool's version info and exit

    查看qb版本信息:

    ❯ ./qb-tracker-update-bulk.amd64 -cli -a https://192.168.8.123:8011 -u admin -p mypassword -i
    INFO[2019-12-15 21:48:44] qBittorrent version: v4.2.0                  
    INFO[2019-12-15 21:48:44] qBittorrent webapiVersion: 2.3               
    INFO[2019-12-15 21:48:44] qBittorrent buildInfo: {"bitness":64,"boost":"1.69.0","libtorrent":"1.2.2.0","openssl":"1.1.1d","qt":"5.12.4","zlib":"1.2.11"}

    批量修改tracker:

    ❯ ./qb-tracker-update-bulk.amd64 -cli -a 'qb webui 地址' -u 用户名 -p 密码 -orig '旧tracker地址' -new '新tracker地址' 

    注意事项:

    1. qb WEB UI需要最低 2.2版本才有修改tracker的API,因此太旧的qb客户端是不支持的.

    关于如何查看查看qb web api版本, 见前面的“查看qb版本信息” 命令

    事实上,你不用管这么多。程序都考虑好了。

    如果你的qb web api 版本不会支持,程序会有错误提示的.

    2. 更新速度是非常快的,所以,点击enter或者点击更新按钮前,再三检查是否填写正确.

    下载地址:

    http://nanodm.net/uploads/qb%E6%89%B9%E9%87%8F%E4%BF%AE%E6%94%B9tracker%E5%B7%A5%E5%85%B7-%E5%B8%A6web%E7%95%8C%E9%9D%A2-20191212-release.zip.torrent

    磁力链接:

    magnet:?xt=urn:btih:4c3f23f9b7c7bbeea8020677d922ea89f0a7d2eb&dn=qb%e6%89%b9%e9%87%8f%e4%bf%ae%e6%94%b9tracker%e5%b7%a5%e5%85%b7-%e5%b8%a6web%e7%95%8c%e9%9d%a2-20191212-release.zip

    展开全文
  • 很多以为修改证件照底色只能在电脑上进行修改,别着急,下面让我来教大家在手机上修改证件照底色吧! 第一步,在手机应用商店找到智能证件照相机,并装到手机中进行使用。 第二步,打开智能证件照相机选择证件照...

    如果本身证件照的底色是蓝底,要修改成白底的话,我们该如何解决?很多人以为修改证件照底色只能在电脑上进行修改,别着急,下面让我来教大家在手机上修改证件照底色吧!在这里插入图片描述

    第一步,在手机应用商店里找到智能证件照相机,并装到手机中进行使用。
    第二步,打开智能证件照相机选择证件照的尺寸,即可进行拍照了,在拍照时请尽量选择手机后置摄像头进行拍照;或者已经有照片的可以直接从手机相册上传照片,并等待识别。在这里插入图片描述

    第三步,在完成拍照即可进行预览,若在预览时需要修改证件照的背景颜色,也可以直接在背景颜色里对其进行修改,点击保存即可完成。在这里插入图片描述

    在手机上只需以上三步就可以完成证件照底色的修改啦,大家都学会了吗?要记得把这个小技巧分享给身边有需要的朋友噢!

    展开全文
  • 一分钟教你如何导出PPT里面照片最近,有网友问我,如何把PPT里面照片导出来,我们一般情况,很多提取照片都是一张一张复制每一张图片,然后另存为,或都直接截图,其实这样很费时间,我今天教大家一非常方便方法...

    一分钟教你如何导出PPT里面照片

    最近,有网友问我,如何把PPT里面照片导出来,我们一般情况,很多人提取照片都是一张一张复制每一张图片,然后另存为,或都直接截图,其实这样很费时间,我今天教大家一非常方便的方法,一键提取PPT里面的照片,轻松搞定办公。

    下面我来说下如何操作,先找到一个pptx文件,然后点击文件的右键,如下图

    cd3f0c8d3bf93d5a9e7c1babf2470dcc.png

    在属性里面修改,属性里面有个常规-更改,具体下图图

    3f64aeaee6e49b2e0bab8265f6f26419.png

    点击打开更改,更改成打开的软件为压缩包软件,一定要有压缩包软件,压缩包软件后辍名为.rar或者.zip格式的,具体如下图

    cf1c4729f9824c83e9fed44e75c46440.png

    如果面里面没有可以在浏览里面找到压缩包软件,找到后点击确定就可以了,返回看文件已经变成压缩包打开软件了,如下图

    未修改前

    f8630697bf3d4bcf15f93d6edba398db.png

    修改压缩包打开后这样的

    774e7c0adbedfae0215b901a19a87164.png

    然后打开PPT就可以了,双击PPT就会弹出如下

    191c8ac42e1b80a90aba8ad9c5066ed3.png

    找到里面的PPT的一个文件,找到一个叫media媒体文件夹,这个文件夹就是需要在PPT的图片存放出。具体如下图:

    302cc073a3e87b5d4ee70dddd6958a2f.png
    1c4d53acba598b115ec46e2128807655.png

    上面这些图片就是PPT里面的图片,具本你可把整个文件夹一起解压出来,如下图

    42685e18b3ed5d35d5186b69ff3d4a5b.png

    这个功能是很实用呢,也很容易学会,你学会了吧。

    展开全文
  • 相信很多都在用华为手机,里面有很多实用功能,大家都还不知道,在华为手机相册中,只要按下这个按钮,照片秒变电子版。一、相册生成1、首先打开手机相册,选取一张照片,在屏幕左下角点击【更多】,然后...
  • 开发一个方便修改文件名小程序

    千次阅读 2015-06-02 20:58:08
    近期看到刚毕业的师弟师妹们上传了毕业照,有的人把每张照片都修改了与照片内容相关的文件名,可见很怀念大学里的人。我想手动一张一张的修改照片太麻烦了,就用工作使用的Delphi写一个小程序,支持一边翻阅图片一边...
  • 理论上:你可以建立一个你感兴趣的百万级的数据库,给你个照片 ,你就可以得到她是谁,哪里的,信息都可以知道,而且因为人与人之间的网状的关联,你甚至可以知道她喜欢的人是谁,男朋友长啥样子。相信我:一切都...
  • 人为将照片名称修改为身份证号文件,然后根据文件名导入对应人员blob字段中 开发环境: vs2008 oracle10g ODTwithODAC1020221(oracle公司驱动程序,开发时需要,可以使用update语句更新blob字段;oledb使用...
  • 今天我想发文,不为啥,就因为我诈尸了。...可能大家平时遇不到,除非你是班干部,你老师让你收作业,作业是一个word和一张照片,你给大家说,让大家把word和照片放在一个文件夹,压缩打包发你邮箱,文件...
  • 比如对外分享中自我介绍,公司简介里面创始介绍等。今天这篇文章,我会从实际案例出发,带大家修改一份人物介绍页PPT。原稿如下,是这样一页PPT。一份人物介绍页,通常是一段文字介绍,一张人物照片。目前这...
  • 这时候一定有会在评论说:你是在侮辱我吗?哈哈,稍安勿躁在日常使用电脑时候,我们经常会遇到需要修改文件名情况比如:工作中使用表格、文档;或者是下载好电影;再或者是拍摄的照片等等。右击选择...
  • 这时候一定有会在评论说:你是在侮辱我吗?哈哈,稍安勿躁在日常使用电脑时候,我们经常会遇到需要修改文件名情况比如:工作中使用表格、文档;或者是下载好电影;再或者是拍摄的照片等等。右击选择...
  • 但我们有所不知,以“克制”享誉全国的微信,正在悄悄地蚕食着我们的正常时间,我们每一个依赖生产生活的人也成为了微信帝国的养料。 在2021年举办的微信公开课pro上,微信给了这么一组数据: 日活跃用户有10.9亿,3...
  • 因为每个人的手机相册应该都会存有许许多多张照片,直接从相册选取一张现有的照片会比打开相机拍一张照片更加常用。一个优秀应用程序应该将这两种选择方式都提供给用户,由用户来决定使用哪一种。下面我们就来...
  • dede备份文件修改

    2020-02-03 23:39:28
    走一条少有路。 dede后台批量新增文章很慢,网上有些发帖机器,下了几个试了试,很水,另外还有病毒风险。 php和html以前看过,没用全忘了。 临时报佛脚,边学边改,都到前端了,都是各种数据结构。 ...
  • 因为每个人的手机相册应该都会存有许许多多张照片,直接从相册选取一张现有照 片会比打开相机拍一张照片更加常用。一个优秀应用程序应该将这两种选择方式都提供给 用户,由用户来决定使用哪一种。下面我们...
  • 最近看到斗鱼里的照片都不错,决定用最新学习的python技术进行爬取,下面将实现的过程分享出来供大家参考,下面话不多说了,来一起看看详细的介绍吧。 方法如下: 首先下载一个斗鱼(不下载也可以,url都在这了对吧...
  • 唯一的问题是:jhead不是个window程式,它是个DOS程式,许多用window的人,对DOS并不熟,因此,说明jhead使用法如下: jhead这个DOS程式必需在DOS下执行,如何在windows中启动DOS? 以windowsXP为例: 开始——运行 ...
  • 用「文件夹」分类文件,很吃力,不仅涉到复杂「树状结构」,而且修改分类时需要文件在不同文件夹移动由于牵涉到复杂「树状结构」,我们很难一次性想好这个「树」是什么样。用「文件名」来解决?如果不分类...
  • 我们需要对某些图片进行尺寸大小设定,若是几张照片,我们直接在ps改变图片大小之后保存即可,但问题是你若要处理几百张图片尺寸,这种方法是累死不可取,下面说下用ps动作命令进行图片尺寸批量修改。...
  • 1、可以读取固定文件夹里的图片,然后快速随机显示,这样可以为以后添加照片和成员方便 2、刚刚打开有一个开始按钮,点击后,开始,按钮消失 3、回车键、鼠标单击任意位置,可以暂停图片随机显示和开始图片随机...
  • 但最近,推出 Photoshop 的 Adobe 这次终于有所表示了:你们论文里的效果,我们打包实现了。机器之心报道,编辑:张倩、陈萍。这两年,我们从很多论文中看到过一些令惊艳的 demo,比如老照片自动上色、低画质图像...
  • 简单TT同学录

    2021-03-23 23:07:53
    简单TT同学录,做了一下更新 1.增加后台管理 2.后台修改网站配置, 3.支持更多同学图片、增加、修改同学信息、新闻等等。...可以直接在数据库里面修改网站系统参数了,另外修改照片在imgurl表里面
  • 简单TT 同学录,做了一下更新 1.增加后台管理 2.后台修改网站配置, 3.支持更多同学图片、增加、修改同学信息、新闻等等。...可以直接在数据库里面修改网站系统参数了,另外修改照片在imgurl表里面
  • 1、先找一下对应功能有没有早之前项目中做过,可以直接打包过来,进行适当修改使用 2、检查美工给资源和动画是否符合要求,需不需要自己再修改 ...canvas中同样光标,照片,文字框可以进行ctrl+d进行复制,.
  • 任何都可以复制、修改、发行和表演作品,甚至用于商业用途,无需经过同意。 因为一张黑洞照片,视觉中国被顶上了风口浪尖,讨论焦点主要集中在「图片版权」上。网上图片一搜一大堆,但版权归属错综复杂,一不...
  • 导语:在互联网公司里面,若把他们最讨厌的人排出个123来,产品经理绝对能进前3。对于产品经理们各种奇葩需求,无休止的修改让程序员们苦不堪言。不只是临时增加需求,一些项目经理在需求表达上,也会让沟通的程序员...
  • Picasa 甚至还具有星标搜索功能,可在 1 秒钟之内找出整个照片那些好上加好的照片。 在多个相册中保存同一张图片。 Picasa 为您标记每张照片都创建“例图”而不占用计算机空间,因此,您可以将同一张图片放在...
  • 超个性VB通讯录小程序,里面包括了通讯簿源码示例---之菜单提示特效构建类、菜单特效构建类、数据库操作类等。本程序特点:使用动画效果显示窗体背景...其它一些操作比较简单,比如添加、删除、修改通讯录内容等。

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 135
精华内容 54
关键字:

修改照片里的人