标签: reducing

我试图将一些文件转换为ProRes.转换的一个相当重要的部分是:

• 将帧数从60减少到30
• 将每2帧混合成一个,实现更流畅的运动.(一种简单的运动模糊)

我已经尝试过该-blend命令,但它没有被识别为命令.

-i source.mp4 -r 30 -vcodec prores_ks -profile:v 0 Output.mov

如何在ffmpeg中混合减少帧？

对于我的具体情况，我想减少使用功能组合；例如：

BiFunction<ImmutableSet<Integer>, ImmutableSet<Integer>, Sets.SetView<Integer>> f = Sets::intersection;
Function<Sets.SetView<Integer>, ImmutableSet<Integer>> g = Sets.SetView::immutableCopy;
BiFunction<ImmutableSet<Integer>, ImmutableSet<Integer>, ImmutableSet<Integer>> biFunction = f.andThen(g);
ImmutableSet<Integer> intersection = Stream.of(ImmutableSet.of(1, 2, 3), ImmutableSet.of(1, 2), ImmutableSet.of(4))
    .reduce(biFunction)
    .orElse(ImmutableSet.of());

这有一个编译错误：

BiFunction<ImmutableSet<Integer>, ImmutableSet<Integer>, Sets.SetView<Integer>> f = Sets::intersection;
Function<Sets.SetView<Integer>, ImmutableSet<Integer>> g = Sets.SetView::immutableCopy;
BiFunction<ImmutableSet<Integer>, ImmutableSet<Integer>, ImmutableSet<Integer>> biFunction = f.andThen(g);
ImmutableSet<Integer> intersection = Stream.of(ImmutableSet.of(1, 2, 3), ImmutableSet.of(1, 2), ImmutableSet.of(4))
    .reduce(biFunction)
    .orElse(ImmutableSet.of());

相反，我需要这样做：

ImmutableSet<Integer> intersection = Stream.of(ImmutableSet.of(1, 2, 3), ImmutableSet.of(1, 2), ImmutableSet.of(4))
    .reduce((a, b) -> Sets.intersection(a, b).immutableCopy())
    .orElse(ImmutableSet.of());

然而，这失去了组合提供的无点风格。

为什么 Stream API …

场景:我有一个记录此CSV示例中的事件的服务:

#TimeStamp, Name, ColorOfPullover
TimeStamp01, Peter, Green
TimeStamp02, Bob, Blue
TimeStamp03, Peter, Green
TimeStamp04, Peter, Red
TimeStamp05, Peter, Green

例如彼得穿绿色的事件将经常连续发生.

我有两个目标:

1. 保持数据尽可能小
2. 保留所有相关数据

相关办法:我想知道,在这种时间跨度一个人是穿什么颜色.例如:

#StartTime, EndTime, Name, ColorOfPullover
TimeStamp01, TimeStamp03, Peter, Green
TimeStamp02, TimeStamp02, Bob, Blue
TimeStamp03, TimeStamp03, Peter, Green
TimeStamp04, TimeStamp04, Peter, Red
TimeStamp05, TimeStamp05, Peter, Green

在这种格式中,我可以回答以下问题:Peter在TimeStamp02时穿的是哪种颜色？(我可以放心地假设每个人在相同颜色的两个记录事件之间穿着相同的颜色.)

主要问题:我可以使用现有技术来实现这一目标吗？即我可以提供连续的事件流,并提取和存储相关数据？

确切地说,我需要实现这样的算法(伪代码).OnNewEvent为CSV示例的每一行调用该方法.其中参数event已包含来自行的数据作为成员变量.

def OnNewEvent(even)
    entry = Database.getLatestEntryFor(event.personName)
    if (entry.pulloverColor == event.pulloverColor)
        entry.setIntervalEndDate(event.date)
        Database.store(entry)
    else
        newEntry = …

我有一个 Item 类，其中包含代码、数量和金额字段，以及可能包含许多项目（具有相同代码）的项目列表。我想按代码对项目进行分组并汇总它们的数量和金额。

我能够使用流groupingBy和实现一半的目标reduce。分组有效，但减少是将所有分组的项目减少为一个在不同代码（groupingBy键）上重复的单个项目。

不应该在此处减少减少地图中每个代码的项目列表吗？为什么它要为所有人重新调整相同的组合项目。

下面是示例代码。

import java.util.List;
import java.util.Arrays;
import java.util.stream.Collectors;
import java.util.Map;

class HelloWorld {
    public static void main(String[] args) {
        List<Item> itemList = Arrays.asList(
            createItem("CODE1", 1, 12),
            createItem("CODE2", 4, 22),
            createItem("CODE3", 5, 50),
            createItem("CODE4", 2, 11),
            createItem("CODE4", 8, 20),
            createItem("CODE2", 1, 42)
        );
        
        Map<String, Item> aggregatedItems = itemList
            .stream()
            .collect(Collectors.groupingBy(
                Item::getCode,
                Collectors.reducing(new Item(), (aggregatedItem, item) -> {
                    int aggregatedQuantity = aggregatedItem.getQuantity();
                    double aggregatedAmount = aggregatedItem.getAmount();
                    
                    aggregatedItem.setQuantity(aggregatedQuantity + item.getQuantity());
                    aggregatedItem.setAmount(aggregatedAmount + item.getAmount()); …

是否设置了设计模式,或者每个人都是足够熟练的软件开发人员是否认识并减少了他们的代码以开发新模 有效地创建自己的"设计"模式.

编辑 - 感谢您的回复.实际上,我只是重构和/或减少代码,在编写代码之前,应首先将问题与现有设计模式进行比较.如果找到匹配,那么我应该使用它,否则我只是重构代码(这不是一件坏事,通常不会产生任何新的通常有用的"模式".)

我正在尝试获取类型A -> A为 的地图，并将其分组为A to List<A>. （也颠倒了键值关系，但我认为这不一定相关）。

这就是我现在所拥有的：

private static Map<Thing, List<Thing>> consolidateMap(Map<Thing, Thing> releasedToDraft) {

    // Map each draft Thing back to the list of released Things (embedded in entries)
    Map<Thing, List<Map.Entry<Thing, Thing>>> draftToEntry = releasedToDraft.entrySet().stream()
            .collect(groupingBy(
                    Map.Entry::getValue,
                    toList()
            ));

    // Get us back to the map we want (Thing to list of Things)
    return draftToEntry.entrySet().stream()
            .collect(toMap(
                    Map.Entry::getKey,
                    ThingReleaseUtil::entriesToThings
            ));
}

private static List<Thing> entriesToThings(Map.Entry<Thing, List<Map.Entry<Thing, Thing>>> entry) {
    return entry.getValue().stream()
            .map(Map.Entry::getKey)
            .collect(toList());
}

我想在单个语句中执行此操作，并且我觉得必须可以将 …

我试图获取一个元素列表，对这些元素的一部分进行一些操作，并将这些操作的输出放在一个新列表中。我只想在列表中进行一次迭代。

我发现这样做的唯一方法是：

List<Integer> newList = numList.stream().reduce(new ArrayList<Integer>(),
            (acc, value) -> {
                if (value % 2 == 0) {
                    acc.add(value * 10);
                }
                return acc;
            },
            (l1, l2) -> {
                l1.addAll(l2);
                return l1;
            }
        );

如您所见，这非常麻烦。

我当然可以使用filterand then map，但在这种情况下，我将列表迭代两次。

在其他语言（例如Javascript）中，这种reduce操作非常简单，例如：

arr.reduce((acc, value) => { 
    if (value % 2 == 0) {
        acc.push(value * 10);
    }
    return acc;
}, new Array())

惊人的！我在想 Java 是否有更好的版本来减少这种减少，或者我编写的 Java 代码是执行此类操作的最短方法。

int val = integerList.stream().collect(
        Collectors.reducing(0, a1 -> a1 * 5, (a1, a2) -> a1 + a2));

上面的代码进行了归约操作。转换整数流和聚合函数以返回 Integer 。我无法理解以下代码和归约操作的内部实现。Java 如何执行以下有状态功能？谢谢！

java.util.stream.Collectors:reducing method
    public static <T, U>
    Collector<T, ?, U> reducing(U identity,
                                Function<? super T, ? extends U> mapper,
                                BinaryOperator<U> op) {
        return new CollectorImpl<>(
                boxSupplier(identity),
                (a, t) -> { a[0] = op.apply(a[0], mapper.apply(t)); },
                (a, b) -> { a[0] = op.apply(a[0], b[0]); return a; },
                a -> a[0], CH_NOID);
    }

可能是，我会更好地澄清我的问题。上面的实现是如何获取数据流的。a[0],b[0] 是指数据流吗？我相信以上是为供应商和累加器提供功能实现。我想通过代码了解缩减过程是如何工作的。