C# 加入tiff图像时，SetResolution不执行任何操作

我一直在尝试为一组其他tiff创建的新tiff调整分辨率。我想把分辨率降到100x100 dpi。连接的一切都正常工作，但最终tiff中的分辨率始终与我连接的文件的分辨率相同（使用300x300 dpi图像）。我尝试使用一些建议（）来获取/设置PropertyItems，但也失败了。使用下面的连接技术，将最终图像的分辨率设置为100x100 dpi的正确方法是什么

多谢各位

public byte[] JoinTiffImages(
        List<byte[]> images)
    {
        var fPage = FrameDimension.Page;

        var nearest =
            System.Drawing
                  .Drawing2D
                  .InterpolationMode
                  .NearestNeighbor;

        if (images.Count == 0)
        {
            throw new ImageConverterException(
                "Could not join an empty set of images.");
        }
        else if (images.Count == 1)
        {
            return images[0];
        }
        else
        {
            using (var ms = new MemoryStream())
            {
                using (var masterBitmap =
                    (Bitmap)DrawingImage.FromStream(
                        new MemoryStream(images[0])))
                {
                    //get the codec for tiff files
                    var info = GetTifCodecInfo();
                    var enc = Encoder.SaveFlag;
                    var ep = new EncoderParameters(2);

                    ep.Param[0] = new EncoderParameter(
                        enc,
                        (long)EncoderValue.MultiFrame);

                    ep.Param[1] = new EncoderParameter(
                        Encoder.Compression,
                        (long)TifCompression.ToEncoderValue());

                    masterBitmap.SetResolution(100.0f, 100.0f);
                    masterBitmap.Save(ms, info, ep);

                    //save the intermediate frames
                    ep.Param[0] = new EncoderParameter(
                        enc,
                        (long)EncoderValue.FrameDimensionPage);

                    for (int i = 1; i < images.Count; i++)
                    {
                        using (var nextImg = (Bitmap)DrawingImage.FromStream(
                            new MemoryStream(images[i])))
                        {
                            for (int x = 0;
                                    x < nextImg.GetFrameCount(fPage);
                                    x++)
                            {
                                nextImg.SetResolution(100.0f, 100.0f);
                                nextImg.SelectActiveFrame(fPage, x);

                                masterBitmap.SaveAdd(nextImg, ep);
                            }
                        }
                    }

                    ep.Param[0] =
                        new EncoderParameter(
                            enc,
                            (long)EncoderValue.Flush);

                    //close out the file.
                    masterBitmap.SaveAdd(ep);

                    return ms.ToArray();
                }
            }
        }
    }

public byte[]jointiff图像(
列出图像）
{
var fPage=FrameDimension.Page；
最近值=
系统图
.绘图2D
.插值模式
.最近的邻居；
如果（images.Count==0）
{
抛出新的ImageConverterException(
“无法加入空的图像集。”）；
}
else if（images.Count==1）
{
返回图像[0]；
}
其他的
{
使用（var ms=new MemoryStream（））
{
使用（var）主位图=
（位图）DrawingImage.FromStream(
新内存流（图像[0]））
{
//获取tiff文件的编解码器
var info=GetTifCodecInfo（）；
var enc=Encoder.SaveFlag；
var ep=新编码器参数（2）；
ep.Param[0]=新编码器参数(
enc，
（长）编码器值（多帧）；
ep.Param[1]=新编码器参数(
编码器，压缩，
（long）TifCompression.ToEncoderValue（））；
masterBitmap.SetResolution（100.0f，100.0f）；
主位图。保存（ms、信息、ep）；
//保存中间帧
ep.Param[0]=新编码器参数(
enc，
（长）EncoderValue.FrameDimensionPage）；
对于（int i=1；i

下面是一段代码，用于从图像列表创建多页tif文件。 它根据输入参数将DPI设置为主部件和所有部件

private void saveTiff_Click(List<Image> imgList, string saveName,  int dpi)
{
    //all kudos to : http://bobpowell.net/generating_multipage_tiffs.aspx

    foreach (Image img in imgList) ((Bitmap)img).SetResolution(dpi, dpi);

    System.Drawing.Imaging.Encoder enc = System.Drawing.Imaging.Encoder.SaveFlag;
    Bitmap master = new Bitmap(imgList[0]);
    master.SetResolution(dpi, dpi);
    ImageCodecInfo info = null;

    // lets hope we have an TIF encoder
    foreach (ImageCodecInfo ice in ImageCodecInfo.GetImageEncoders())
        if (ice.MimeType == "image/tiff")  info = ice;

    // one parameter: MultiFrame
    EncoderParameters ep = new EncoderParameters(1);
    ep.Param[0] = new EncoderParameter(enc, (long)EncoderValue.MultiFrame);
    master.Save(saveName, info, ep);

    // one parameter: further frames
    ep.Param[0] = new EncoderParameter(enc, (long)EncoderValue.FrameDimensionPage);
    for (int i = 1; i < imgList.Count; i++)  master.SaveAdd(imgList[i], ep);

    // one parameter: flush
    ep.Param[0] = new EncoderParameter(enc, (long)EncoderValue.Flush);
    master.SaveAdd(ep);
}

private void saveTiff\u单击（列出imgList、字符串saveName、int dpi）
{
//所有荣誉：http://bobpowell.net/generating_multipage_tiffs.aspx
foreach（imgList中的图像img）（（位图）img）.设置分辨率（dpi，dpi）；
System.Drawing.Imaging.enc=System.Drawing.Imaging.Encoder.SaveFlag；
位图主机=新位图（imgList[0]）；
主分辨率（dpi，dpi）；
ImageCodecInfo=null；
//希望我们有一个TIF编码器
foreach（ImageCodecInfo.GetImageEncoders（）中的ImageCodecInfo）
如果（ice.MimeType==“image/tiff”）info=ice；
//一个参数：多帧
编码器参数ep=新编码器参数（1）；
ep.Param[0]=新编码器参数（enc，（long）EncoderValue.MultiFrame）；
master.Save（保存名称、信息、ep）；
//一个参数：更多帧
ep.Param[0]=新编码器参数（enc，（long）EncoderValue.FrameDimensionPage）；
对于（inti=1；i

在评论的帮助下，我解决了我的问题。此函数将在图像大小不变的情况下处理分辨率变化

public static byte[] JoinTiffImages(
    List<byte[]> images,
    float res)
{
    var fPage = FrameDimension.Page;

    var nearest =
        System.Drawing
                .Drawing2D
                .InterpolationMode
                .NearestNeighbor;

    if (images.Count == 0)
    {
        throw new Exception(
            "Could not join an empty set of images.");
    }
    else if (images.Count == 1)
    {
        return images[0];
    }
    else
    {
        var ms = new MemoryStream();

        //get the codec for tiff files
        var info = GetTifCodecInfo();
        var ep = new EncoderParameters(2);

        ep.Param[0] = new EncoderParameter(
            System.Drawing.Imaging.Encoder.SaveFlag,
            (long)EncoderValue.MultiFrame);

        ep.Param[1] = new EncoderParameter(
            System.Drawing.Imaging.Encoder.Compression,
            (long)EncoderValue.CompressionLZW);

        using (var masterImg =
            (Bitmap)System.Drawing.Image.FromStream(
                new MemoryStream(images[0])))
        {
            using (var resizedMaster =
                new Bitmap(
                    (int)(masterImg.Width *
                        (res /
                            masterImg.HorizontalResolution)),
                    (int)(masterImg.Height *
                        (res /
                            masterImg.VerticalResolution))))
            {
                resizedMaster.SetResolution(
                    res,
                    res);

                using (var gr = Graphics.FromImage(resizedMaster))
                {
                    gr.InterpolationMode = nearest;

                    gr.DrawImage(
                        masterImg,
                        new Rectangle(
                            0,
                            0,
                            resizedMaster.Width,
                            resizedMaster.Height),
                        0,
                        0,
                        masterImg.Width,
                        masterImg.Height,
                        GraphicsUnit.Pixel);
                }

                resizedMaster.Save(ms, info, ep);

                //save the intermediate frames
                ep.Param[0] = new EncoderParameter(
                    System.Drawing.Imaging.Encoder.SaveFlag,
                    (long)EncoderValue.FrameDimensionPage);

                for (int i = 1; i < images.Count; i++)
                {
                    using (var nextImg =
                        (Bitmap)System.Drawing.Image.FromStream(
                        new MemoryStream(images[i])))
                    {
                        for (int x = 0;
                            x < nextImg.GetFrameCount(fPage);
                            x++)
                        {
                            nextImg.SelectActiveFrame(fPage, x);

                            using (var resizedNext =
                                new Bitmap(
                                    (int)(nextImg.Width *
                                        (res /
                                            nextImg.HorizontalResolution)),
                                    (int)(nextImg.Height *
                                        (res /
                                            nextImg.VerticalResolution))))
                            {
                                resizedNext.SetResolution(
                                    res,
                                    res);

                                using (var gr =
                                    Graphics.FromImage(resizedNext))
                                {
                                    gr.InterpolationMode = nearest;
                                    gr.DrawImage(
                                        nextImg,
                                        new Rectangle(
                                            0,
                                            0,
                                            resizedNext.Width,
                                            resizedNext.Height),
                                        0,
                                        0,
                                        nextImg.Width,
                                        nextImg.Height,
                                        GraphicsUnit.Pixel);
                                }

                                resizedMaster.SaveAdd(resizedNext, ep);
                            }
                        }
                    }
                }

                ep.Param[0] =
                    new EncoderParameter(
                        System.Drawing.Imaging.Encoder.SaveFlag,
                        (long)EncoderValue.Flush);

                //close out the file.
                resizedMaster.SaveAdd(ep);
            }

            return ms.ToArray();
        }
    }
}

private static ImageCodecInfo GetTifCodecInfo()
{
    foreach (var ice in ImageCodecInfo.GetImageEncoders())
    {
        if (ice.MimeType == "image/tiff")
        {
            return ice;
        }
    }

    return null;
}

publicstaticbyte[]jointiff图像(
列出图像，
浮点数（res）
{
var fPage=FrameDimension.Page；
最近值=
系统图
.绘图2D
.插值模式
.最近的邻居；
如果（images.Count==0）
{
抛出新异常(
“无法加入空的图像集。”）；
}
else if（images.Count==1）
{
返回图像[0]；
}
其他的
{
var ms=新内存流（）；
//获取tiff文件的编解码器
var info=GetTifCodecInfo（）；
var ep=新编码器参数（2）；
ep.Param[0]=新编码器参数(
System.Drawing.Imaging.Encoder.SaveFlag，
（长）编码器值（多帧）；
ep.Param[1]=新编码器参数(
系统、绘图、成像、编码器、压缩、，
（长）编码器右值压缩LZW）；
使用（var-masterImg）=
（位图）System.Drawing.Image.FromStream(
新内存流（图像[0]））
{
使用（var resizedMaster）=
新位图(
（内部）（主宽度*
（res/
掌握水平分辨率），
（内部）（主高度）*