精华内容
下载资源
问答
  • 时间切片特征衍生

    2019-10-28 20:31:48
    这样的变量,使用sum(case when date then amount else 0 end) 即可,如果是出差在外只能处理离线数据不能使用数据库时,这个时候就要用python去构造时间切片类的特征。整理了自己之前写过的代码,往往都太笨拙和...

    在sql中比较容易处理类似“近n个月金额之和/最大值/最小值/平均值” 这样的变量,使用sum(case when date  then amount else 0 end) 即可,如果是出差在外只能处理离线数据不能使用数据库时,这个时候就要用python去构造时间切片类的特征。整理了自己之前写过的代码,往往都太笨拙和重复。

    import pandas as pd
    import numpy as np
    import time as time
    #生成实例数据集
    data = pd.DataFrame({'id':['a','a','b','b','a'],
                        'billdate': ['2018-09-01','2018-08-01','2018-08-01','2018-01-01','2018-11-01'],
                        'amount':list(np.random.randint(1,100,5)),
                        'interest':np.random.rand(5),
                        'dt': ['2018-10-01','2018-10-01','2018-11-01','2018-11-01','2018-10-01']
                        })
    data

    # 首先计算时间差
    def month_sub(d1, d2):
        year = int(d1[:4]) - int(d2[:4])
        month = int(d1[5:7]) - int(d2[5:7])
        return year*12 + month
    data['month_diff'] = data.apply(lambda row: month_sub(row['dt'], row['billdate']), axis=1)
    def feature(data,cols:list,months:list,only_mark,merge_ori=True):
        start = time.time()
        # 原数据集的 唯一主键
        df = pd.DataFrame({only_mark:list(set(data[only_mark]))})
        for month in months:
            df1 = pd.DataFrame({only_mark:list(set(data[only_mark]))})
            for col in cols:
                agg_dict = {
                            "last_%s_%s_count"%(month,col):"count",
                            "last_%s_%s_sum"%(month,col):"sum",
                            "last_%s_%s_max"%(month,col):"max",
                            "last_%s_%s_min"%(month,col):"min",
                            "last_%s_%s_mean"%(month,col):"mean",
                            "last_%s_%s_var"%(month,col):"var",
                            "last_%s_%s_std"%(month,col):"std",
                            "last_%s_%s_median"%(month,col):"median",
                            "last_%s_%s_skew"%(month,col):"skew"
                                                                    }
                # 选取时间切片内的数据 进行groupby聚合计算
                sta_data = data[data['month_diff']<=month].groupby([only_mark])[col].agg(agg_dict).reset_index()
                df1 = df1.merge(sta_data,how = "left",on = only_mark)
            df = df.merge(df1,how = "left",on = only_mark)
        # 是否与原数据集关联  
        if merge_ori:
            print("merge the original data")
            df = df.merge(data,how="right",on=only_mark).fillna(0) #视情况定 是否需要填充0
        else:
            df = df.fillna(0)
        end = time.time()
        cost = end-start
        print("cost time %.2f s"%(cost))
        return  df
    if __name__=="__main__":
        cols = ['amount', 'interest']
        months = [1,3]
        result=feature(data,cols,months,"id",merge_ori = 0)

    展开全文
  • 时间切片(Time Slicing)

    千次阅读 2019-05-20 06:31:18
    上周我在FDConf的分享《让你的网页更丝滑》中提到了“时间切片”,由于时间关系当时并没有对时间切片展开更细致的讨论。所以回来后就想着补一篇文章针对“时间切片”展开详细的讨论。 从用户的输入,再到显示器在...

    上周我在FDConf的分享《让你的网页更丝滑》中提到了“时间切片”,由于时间关系当时并没有对时间切片展开更细致的讨论。所以回来后就想着补一篇文章针对“时间切片”展开详细的讨论。

    从用户的输入,再到显示器在视觉上给用户的输出,这一过程如果超过100ms,那么用户会察觉到网页的卡顿,所以为了解决这个问题,每个任务不能超过50ms,W3C性能工作组在LongTask规范中也将超过50ms的任务定义为长任务。

    关于这50毫秒我在FDConf的分享中进行了很详细的讲解,没有听到的小伙伴也不用着急,后续我会针对这次分享的内容补一篇文章。

    在线PPT地址:ppt.baomitu.com/d/b267a4a3

    所以为了避免长任务,一种方案是使用Web Worker,将长任务放在Worker线程中执行,缺点是无法访问DOM,而另一种方案是使用时间切片。

    什么是时间切片

    时间切片的核心思想是:如果任务不能在50毫秒内执行完,那么为了不阻塞主线程,这个任务应该让出主线程的控制权,使浏览器可以处理其他任务。让出控制权意味着停止执行当前任务,让浏览器去执行其他任务,随后再回来继续执行没有执行完的任务。

    所以时间切片的目的是不阻塞主线程,而实现目的的技术手段是将一个长任务拆分成很多个不超过50ms的小任务分散在宏任务队列中执行。

    上图可以看到主线程中有一个长任务,这个任务会阻塞主线程。使用时间切片将它切割成很多个小任务后,如下图所示。

    可以看到现在的主线程有很多密密麻麻的小任务,我们将它放大后如下图所示。

    可以看到每个小任务中间是有空隙的,代表着任务执行了一小段时间后,将让出主线程的控制权,让浏览器执行其他的任务。

    使用时间切片的缺点是,任务运行的总时间变长了,这是因为它每处理完一个小任务后,主线程会空闲出来,并且在下一个小任务开始处理之前有一小段延迟。

    但是为了避免卡死浏览器,这种取舍是很有必要的。

    如何使用时间切片

    时间切片是一种概念,也可以理解为一种技术方案,它不是某个API的名字,也不是某个工具的名字。

    事实上,时间切片充分利用了“异步”,在早期,可以使用定时器来实现,例如:

    btn.onclick = function () {
      someThing(); // 执行了50毫秒
      setTimeout(function () {
        otherThing(); // 执行了50毫秒
      });
    };
    复制代码

    上面代码当按钮被点击时,本应执行100毫秒的任务现在被拆分成了两个50毫秒的任务。

    在实际应用中,我们可以进行一些封装,封装后的使用效果类似下面这样:

    btn.onclick = ts([someThing, otherThing], function () {
      console.log('done~');
    });
    复制代码

    当然,关于ts这个函数的API的设计并不是本文的重点,这里想说明的是,在早期可以利用定时器来实现“时间切片”。

    ES6带来了迭代器的概念,并提供了生成器Generator函数用来生成迭代器对象,虽然Generator函数最正统的用法是生成迭代器对象,但这不妨我们利用它的特性做一些其他的事情。

    Generator函数提供了yield关键字,这个关键字可以让函数暂停执行。然后通过迭代器对象的next方法让函数继续执行。

    对Generator函数不熟悉的同学,需要先学习Generator函数的用法。

    利用这个特性,我们可以设计出更方便使用的时间切片,例如:

    btn.onclick = ts(function* () {
      someThing(); // 执行了50毫秒
      yield;
      otherThing(); // 执行了50毫秒
    });
    复制代码

    可以看到,我们只需要使用yield这个关键字就可以将本应执行100毫秒的任务拆分成了两个50毫秒的任务。

    我们甚至可以将yield关键字放在循环里:

    btn.onclick = ts(function* () {
      while (true) {
        someThing(); // 执行了50毫秒
        yield;
      }
    });
    复制代码

    上面代码我们写了一个死循环,但依然不会阻塞主线程,浏览器也不会卡死。

    基于生成器的ts实现原理

    通过前面的例子,我们会发现基于Generator的时间切片非常好用,但其实ts函数的实现原理非常简单,一个最简单的ts函数只需要九行代码

    function ts (gen) {
      if (typeof gen === 'function') gen = gen()
      if (!gen || typeof gen.next !== 'function') return
      return function next() {
        const res = gen.next()
        if (res.done) return
        setTimeout(next)
      }
    }
    复制代码

    代码虽然全部只有9行,关键代码只有3、4行,但这几行代码充分利用了事件循环机制以及Generator函数的特性。

    创造出这样的代码我还是很开心的。

    上面代码核心思想是:通过yield关键字可以将任务暂停执行,从而让出主线程的控制权;通过定时器可以将“未完成的任务”重新放在任务队列中继续执行。

    避免把任务分解的过于零碎

    使用yield来切割任务非常方便,但如果切割的粒度特别细,反而效率不高。假设我们的任务执行100ms,最好的方式是切割成两个执行50ms的任务,而不是切割成100个执行1ms的任务。假设被切割的任务之间的间隔为4ms,那么切割成100个执行1ms的任务的总执行时间为:

    (1 + 4) * 100 = 500ms
    复制代码

    如果切割成两个执行时间为50ms的任务,那么总执行时间为:

    (50 + 4) * 2 = 108ms
    复制代码

    可以看到,在不影响用户体验的情况下,下面的总执行时间要比前面的少了4.6倍。

    保证切割的任务刚好接近50ms,可以在用户使用yield时自行评估,也可以在ts函数中根据任务的执行时间判断是否应该一次性执行多个任务。

    我们将ts函数稍微改进一下:

    function ts (gen) {
      if (typeof gen === 'function') gen = gen()
      if (!gen || typeof gen.next !== 'function') return
      return function next() {
        const start = performance.now()
        let res = null
        do {
          res = gen.next()
        } while(!res.done && performance.now() - start < 25);
    
        if (res.done) return
        setTimeout(next)
      }
    }
    复制代码

    现在我们测试下:

    ts(function* () {
      const start = performance.now()
      while (performance.now() - start < 1000) {
        console.log(11)
        yield
      }
      console.log('done!')
    })();
    复制代码

    这段代码在之前的版本中,在我的电脑上可以打印出 215 次 11,在后面的版本中可以打印出 6300 次 11,说明在总时间相同的情况下,可以执行更多的任务。

    再看另一个例子:

    ts(function* () {
      for (let i = 0; i < 10000; i++) {
        console.log(11)
        yield
      }
      console.log('done!')
    })();
    复制代码

    在我的电脑上,这段代码在之前的版本中,被切割成一万个小任务,总执行时间为 46秒,在之后的版本中,被切割成 52 个小任务,总执行时间为 1.5秒。

    总结

    我将时间切片的代码放在了我的Github上,感兴趣的可以参观下:github.com/berwin/time…

    转载于:https://juejin.im/post/5ce249896fb9a07ea712e26e

    展开全文
  • 一直对时间切片非常感兴趣,虽然最新的vue-next中剔除了时间切片,但是这里还是可以借鉴下其中的原理和思想: 首先要先知道javascript的执行机制,javascript的任务分为macro-task宏任务和micro-task微任务,宏任务...

    一直对时间切片非常感兴趣,虽然最新的vue-next中剔除了时间切片,但是这里还是可以借鉴下其中的原理和思想:

    首先要先知道javascript的执行机制,javascript的任务分为macro-task宏任务和micro-task微任务,宏任务主要为同步代码,settimeout,setInterval等,微任务为promise,process.nextTick等。网上有一张图能比较清楚的说明两者相互间的关系:

    大致明白了宏任务和微任务,理解时间切片就简单多了。切入代码可以先从测试文件开始:

    it('queueJob', async () => {
      const calls: any = []
      const job1 = () => {
        calls.push('job1')
      }
      const job2 = () => {
        calls.push('job2')
      }
      queueJob(job1)
      queueJob(job2)
      expect(calls).toEqual([])
      await nextTick()
      expect(calls).toEqual(['job1', 'job2'])
    })

    这里使用了2个函数,queueJob和nextTick,queueJob源码如下:

    export function queueJob(rawJob: Function) {
      console.log(rawJob)
      const job = rawJob as Job
      if (currentJob) {
        currentJob.children.push(job)
      }
      // Let's see if this invalidates any work that
      // has already been staged.
      if (job.status === JobStatus.PENDING_COMMIT) {
        // staged job invalidated
        invalidateJob(job)
        // re-insert it into the stage queue
        requeueInvalidatedJob(job)
      } else if (job.status !== JobStatus.PENDING_STAGE) {
        // a new job
        queueJobForStaging(job)
      }
      if (!hasPendingFlush) {
        hasPendingFlush = true
        flushAfterMicroTask()
      }
    }

    其中rawJob就是我们传入queueJob的匿名函数,通过执行queueJob函数首先会将他推入stageQueue队列,执行queueJob(job1)时,hasPendingFlush为false,则执行flushAfterMicroTask函数,后续的queueJob则不会flushAfterMicroTask。flushAfterMicroTask源码如下:

    function flushAfterMicroTask() {
      flushStartTimestamp = getNow()
      return p.then(flush).catch(handleError)
    }

    代码很简单,就是将在flush函数放入微任务队列中,当宏任务执行完成,就会执行flush函数,简单来说,就是先将要执行的一组任务推入stageQueue,执行完成后执行微任务即执行一次flush。很显然,flush就是时间切片的关键,源码如下:

    function flush(): void {
      let job
      while (true) {
        // console.log(stageQueue)
        job = stageQueue.shift()
        // console.log(job)
        if (job) {
          stageJob(job)
        } else {
          break
        }
        if (!__COMPAT__) {
          const now = getNow()
          if (now - flushStartTimestamp > frameBudget && job.expiration > now) {
            break
          }
        }
      }
    
      if (stageQueue.length === 0) {
        // all done, time to commit!
        for (let i = 0; i < commitQueue.length; i++) {
          commitJob(commitQueue[i])
        }
        commitQueue.length = 0
        flushEffects()
        // some post commit hook triggered more updates...
        if (stageQueue.length > 0) {
          if (!__COMPAT__ && getNow() - flushStartTimestamp > frameBudget) {
            return flushAfterMacroTask()
          } else {
            // not out of budget yet, flush sync
            return flush()
          }
        }
        // now we are really done
        hasPendingFlush = false
        pendingRejectors.length = 0
        for (let i = 0; i < nextTickQueue.length; i++) {
          nextTickQueue[i]()
        }
        nextTickQueue.length = 0
      } else {
        // got more job to do
        // shouldn't reach here in compat mode, because the stageQueue is
        // guarunteed to have been depleted
        flushAfterMacroTask()
      }
    }

    这段代码其实就干两件事,首先stageQueue不断出栈,然后通过stageJob函数推入commitQueue队列,stageJob源码如下:

    function stageJob(job: Job) {
      // job with existing ops means it's already been patched in a low priority queue
      if (job.ops.length === 0) {
        currentJob = job
        job.cleanup = job()
        currentJob = null
        commitQueue.push(job)
        job.status = JobStatus.PENDING_COMMIT
      }
    }

    当超过某个时长或者任务过去则跳出循环。这里frameBudget为16ms左右。之后就是判断如果stageQueue出栈完了都进入commitQueue队列了,则执行commitQueue队列里的job,在vue中,这些job就是挂载组件,副作用更新组件等。如果stageQueue没有清空,那么执行flushAfterMacroTask函数,flushAfterMacroTask函数源码如下:

    function flushAfterMacroTask() {
      window.postMessage(key, `*`)
    }
    
    window.addEventListener(
      'message',
      event => {
        if (event.source !== window || event.data !== key) {
          return
        }
        flushStartTimestamp = getNow()
        try {
          flush()
        } catch (e) {
          handleError(e)
        }
      },
      false
    )

    能看出来接下来就是在宏任务中不断地执行flush函数,直到stageQueue为空,然后执行commitQueue队列中的job。

    讲到这里其实关于时间切片的原理也大致说清楚了,Vue通过queueJob函数,将需要组件挂载和更新的job推入stageQueue队列,然后再之后的宏任务中调用flush函数,不停地将stageQueue出栈,推入commitQueue队列,最后执行job。

    通过这样的方法,可以减少页面的阻断,每次数据更新将其推入stageQueue队列,并不会立即执行,可以看出对于高帧频的操作,有着明显的效果。

    个人认为好像也就能针对高帧频的操作会有效果,也许这就是被废除的原因吧。

    通过vue的时间切片,我们可以尝试写一个建议版的,执行代码如下:

    <!DOCTYPE html>
    <html>
    
    <head>
        <meta charset="utf-8" />
        <title>test</title>
    </head>
    
    <body>
        <input type="text" value="" id="myinput">
        <div id="list"></div>
    </body>
    <script>
        const input = document.getElementById('myinput')
        const list = document.getElementById('list')
    
        function wait(time) {
            const startTime = performance.now()
            while (performance.now() - startTime < time) {}
        }
    
        const stageQueue = []
        const commitQueue = []
        let hasPendingFlush = false
        let flushStartTimestamp = 0
    
        function queueJob(job) {
            stageQueue.push(job)
            if (!hasPendingFlush) {
                hasPendingFlush = true
                flushAfterMicroTask()
            }
        }
    
        function flushAfterMicroTask() {
            console.log('触发微任务')
            flushStartTimestamp = performance.now()
            return Promise.resolve().then(flush)
        }
        window.addEventListener('message', event => {
            console.log('触发message宏任务')
            flushStartTimestamp = performance.now()
            flush()
        }, false)
    
        function flushAfterMacroTask() {
            window.postMessage('$vueTick', `*`)
        }
    
        function flush() {
            let job
            while (true) {
                job = stageQueue.shift()
                if (job) {
                    wait(1) // 模拟生成node节点的时间
                    commitQueue.push(job)
                } else {
                    break
                }
                if (performance.now() - flushStartTimestamp > 16) {
                    break
                }
            }
            if (stageQueue.length === 0) {
                console.log('执行')
                for (let i = 0; i < commitQueue.length; i++) {
                    commitQueue[i]()
                }
                commitQueue.length = 0
                hasPendingFlush = false
            } else {
                flushAfterMacroTask()
            }
        }
    
    
        function job(value) {
            return function () {
                wait(2)
                var node = document.createElement("div");
                var textnode = document.createTextNode(value)
                node.appendChild(textnode)
                list.appendChild(node)
            }
        }
    
        input.oninput = function (event) {
            console.log('触发input宏任务')
            for (let i = 0; i < 200; i++) {
                queueJob(job(event.target.value))
            }
        }
    </script>
    
    </html>

    每次输入input则在div中插入200条数据,这里使用时间切片,可以发现input连着输入时不会卡顿,但是当稍有停顿在输入时明显卡顿,通过代码可以看出卡顿的原因在于,stageQueue为空执行commitQueue中的job时,其实是同步操作,这个时候肯定会造成阻塞,这也是vue废除这个特性的原因,因为vue的渲染都是以组件单最小单位的,组件渲染时间长卡顿的问题通过时间切片无法解决。个人认为这个功能和节流防抖差不多。当然如果是高帧频操作,time slicing对于性能还是有很大帮助的,我们这里可以尝试不同时time scling 运行这段html:

    <!DOCTYPE html>
    <html>
    
    <head>
        <meta charset="utf-8" />
        <title>test</title>
    </head>
    
    <body>
        <input type="text" value="" id="myinput">
        <div id="list"></div>
    </body>
    <script>
        const input = document.getElementById('myinput')
        const list = document.getElementById('list')
    
        function wait(time) {
            const startTime = performance.now()
            while (performance.now() - startTime < time) {}
        }
    
    
        input.oninput = function (event) {
            for (let i = 0; i < 200; i++) {
                wait(2)
                var node = document.createElement("div");
                var textnode = document.createTextNode(event.target.value)
                node.appendChild(textnode)
                list.appendChild(node)
            }
        }
    </script>
    
    </html>

    当连续输入时,卡炸了。

    展开全文
  • 为实现北京市设施农业信息管理系统由静态GIS向时态GIS的转变,解决设施农业时空数据动态存储与表达的问题,针对设施农业数据的时空动态变化特征与情况,结合时间切片模型的思想与方法,提出了设施农业时空数据模型,...
  • 目前Power BI暂不支持切片器选择动态的默认值的功能,只能通过在Power BI Desktop ...到的默认是最新日期的数据,然后通过时间切片器选择其他日期来查看历史的数据。 我们可以通过一种变通的方案来实现此功能: 第一...

    目前Power BI暂不支持切片器选择动态的默认值的功能,只能通过在Power BI Desktop
    中预先选择某个固定值的方式发布到Power BI Service来实现过滤器的默认值效果。这可
    以满足部分的需求,但是对于时间这种实时变化的维度,客户肯定希望每次打开报表,看
    到的默认是最新日期的数据,然后通过时间切片器选择其他日期来查看历史的数据。
    我们可以通过一种变通的方案来实现此功能:
    第一步:创建一个自定义列—Yesterday,用来获取最新的一天的值(通常BI数据是T+1的,所以我这里默认是显示昨天的数据)。
    在这里插入图片描述
    第二步:创建一个条件列—Date Filter
    注意这里的Value选择”Select a column”方式。Output是输出一个文本为”Yesterday”的值。
    在这里插入图片描述
    第三步:在切片器里面使用新创建的”Date Filter”字段来作为时间过滤器
    默认选择值”Yesterday”,这样就可以实现值的动态变化了~
    同理,可以实现默认为当前年或者当前月的效果~
    在这里插入图片描述

    目前这个功能已经在官方的产品优化投票中了,希望可以早点实现此功能。
    https://ideas.powerbi.com/forums/265200-power-bi-ideas/suggestions/7162004-default-selected-slicer-or-tile-by-value-configura?page=4&per_page=20

    展开全文
  • 各位读者大家好,今天工坊为大家带来的是工作技巧分享,如何能够让时间切片器的默认值随年份推移而变化,同时能够查看过去时间的数据呢?一个小小的计算列会帮你找到解决方案。 在实际应用中,往往会有这样的需求,...
  • 使用可变移动窗口k最近邻规则的伪时间切片构造,用于顺序不均匀相分割和批生产过程监控
  • 导入有时间列的excle表,请问用哪个函数可以把时间按年或者按月进行分组,小白求指教,谢谢
  • 切片: 软件:Matlab2013b function wavcut3(t) %%创建文件夹一个文件夹 foldername=num2str(t); foldername=strcat(foldername,'s'); mkdir(foldername); %% a=dir('*.wav');%读取当前文件夹下所有的wav...
  • 项目里面 有这样的需求, 给你两个时间 10月1号 和10月20号。得出 1号到20号之间的 所有天。例如 1号,2号,3号,4号,…20号。 java没有原生的api,或者 是我没找到。 自己写了一个,觉得有些 意思 ,就发篇博客吧 ...
  • 搬运自: 1-https://www.jianshu.com/p/2fba78eb3d72 2-...
  • 今天小编就为大家分享一篇Pandas时间序列基础详解(转换,索引,切片),具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 给一个用户配置SRS,发现浏览器获取切片时间与服务器上切片时间正好差8小时,一开始就怀疑是utc的问题,但是被之前的配置给迷惑了,没有看仔细。 其实只需要修改或添加 utc_time on; 即可。 ...
  • ‘序号’,‘卡号’,‘日期’,‘时间’,‘线路编号’,‘车辆编号’,‘站点编号’,‘上下行标志’,‘卡别’,‘其他’ 1950001 000038072 20180303 092447 105 10505 2 下行 普通卡 1950002 000038072 20180303 093536 ...
  • 今天再为大家介绍一个好用的时间切片器-Timeline Slicer。首先在Marketplace中找到该视觉对象,添加进来,将该对象添加到画布上,它的使用非常简单,只要一个日期类型的字段就可以了,默认的切片器样式长这样,左上...
  • 网页切片

    千次阅读 2017-05-01 15:53:43
    提高网站性能:网页的打开速度与服务器的响应速度和网页的大小有关,如果图片太大,加载时间太长。所以在此情况下,如果用网页切片,会提高网页的加载速度,增强了用户体验。 2.使用的工具 个人喜欢用ps做切片,也...
  • 这个问题不止一个小伙伴问过白茶,就是比如说时间切片器,当选择了某一个具体的时间之后,下次再打开这张报表,希望切片器默认可以选择最新的年份。 多说无益,我们来看看本期的案例: 上图是白茶准备的一张简易的...
  • 地图切片

    2020-05-27 19:21:53
    好处不言而喻,节省了绘制的时间,速度快了,也减轻了服务器的压力。 其实地图很多时候返回的都是图片。比如说,前端用加载动态图层(ArcGISDynamicMapServiceLayer)方式加载arcgis图层,arcgis返回的就是图片;...
  • 实验时间和消耗时间:每个时间是相对于特定开始时间时间的量度,(例如自从被放置在烤箱中每秒烘烤的饼干的直径) 日期和时间数据的类型及工具 datetime模块中的类型: date 使用公历日历存储日历日...
  • 为了弥补传统频谱分析的不足,并建立故障特征与转速的关系,应用波形重构技术,提出了基于等时间采样的阶比切片图分析方法。通过转子实验台设计典型不对中故障,应用阶比切片图分析方法对采集的不对中故障信号进行...
  • 切片平台及工具: 1.切片工具:ArcGIS Desktop,共享切片包; 2.服务工具:ArcGIS Server,服务右键-【管理缓存】-...不需要再在GIS服务器中花时间切片,将时间成本提前。关键是使用【导入地图服务缓存】这个工具,
  • ArcMap切片服务迁移

    2019-12-27 16:21:32
    为了提高前端加载效率,很多底图服务都是切片服务,切片非常占用时间,所以一般遇到切片服务迁移的时候,不会重新切片,而是选择迁移原切片服务。 1. 切片服务迁移 原始服务: (1)重新发布服务,选择和...
  • 三、切片

    2018-07-29 14:01:58
    地图切片,最简单的理解就是将一幅地区切成很多大小一致的小块,在调用的时候,只发送需要的部分,节省带宽和服务器端的渲染时间。ArcGIS可以提供实时地理环境的各种底图,用户可以通过Web地图、Web应用程序、ArcGIS...
  • 前言 在JavaCV开发详解之23:hls视频录制,m3u8切片录制和fmp4切片录制详解,以拉流rtmp录制hls切片为例中我们已经实现了hls的切片录制,但是某些场景需要用到根据日期时间持续不断录像的需要,所以本章就是补充一下...
  • 数组切片

    千次阅读 2016-05-15 17:06:31
    不用失望,Go语言提供了数组切片(slice)这个非常酷的功能来弥补数组的不足。 初看起来,数组切片就像一个指向数组的指针,实际上它拥有自己的数据结构,而不仅仅是个指针。数组切片的数据结构可以抽象为以下3个变
  • 地图切片文档

    2013-01-10 11:06:20
    地图模版发布后,当用户浏览不同比例尺下的地图信息时,整个地图就需要重新加载,这样就需要大量时间。为了提高浏览速度,就需要对发布后的地图进行切片处理,即把发布后的地图切成静态图片。当用户浏览时,浏览的...
  • 切片操作

    2015-12-30 22:27:51
    python中的下标很有威力,切片操作的作用永远超出我们的想象。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,178
精华内容 24,471
关键字:

时间切片